Refine search
/** * <!-- begin-user-doc --> * <!-- end-user-doc --> * @generated */ @Override public Object createFromString(EDataType eDataType, String initialValue) { switch (eDataType.getClassifierID()) { case ColorPackage.HEX_COLOR: return createHexColorFromString(eDataType, initialValue); default: throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier"); } }
/** * <!-- begin-user-doc --> * <!-- end-user-doc --> * @generated */ public String convertTimeDurationTypeToString(EDataType eDataType, Object instanceValue) { if (instanceValue == null) return null; if (XMLTypePackage.Literals.DURATION.isInstance(instanceValue)) { try { String value = XMLTypeFactory.eINSTANCE.convertToString(XMLTypePackage.Literals.DURATION, instanceValue); if (value != null) return value; } catch (Exception e) { // Keep trying other member types until all have failed. } } if (XMLTypePackage.Literals.DECIMAL.isInstance(instanceValue)) { try { String value = XMLTypeFactory.eINSTANCE.convertToString(XMLTypePackage.Literals.DECIMAL, instanceValue); if (value != null) return value; } catch (Exception e) { // Keep trying other member types until all have failed. } } throw new IllegalArgumentException("Invalid value: '"+instanceValue+"' for datatype :"+eDataType.getName()); }
/** * <!-- begin-user-doc --> * <!-- end-user-doc --> * @generated */ public TimeUnit createTimeUnitFromString(EDataType eDataType, String initialValue) { TimeUnit result = TimeUnit.get(initialValue); if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'"); return result; }
private static Object parseValueForDataType(JsonParser jp, EDataType dataType) throws JsonParseException, IOException { if (dataType.getEPackage() == EcorePackage.eINSTANCE) { switch (dataType.getClassifierID()) { case EcorePackage.EBOOLEAN: return jp.getBooleanValue(); case EcorePackage.EBYTE: return jp.getByteValue(); case EcorePackage.ESHORT: return jp.getShortValue(); case EcorePackage.EINT: return jp.getIntValue(); case EcorePackage.ELONG: return jp.getLongValue(); case EcorePackage.EFLOAT: return jp.getFloatValue(); case EcorePackage.EDOUBLE: return jp.getDoubleValue(); case EcorePackage.ESTRING: return jp.getText(); } } return dataType.getEPackage().getEFactoryInstance().createFromString(dataType, jp.getText()); }
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); } }
public SimpleContentFeatureMapEntry(EStructuralFeature.Internal eStructuralFeature) { super(eStructuralFeature); eDataType = (EDataType)eStructuralFeature.getEType(); eFactory = eDataType.getEPackage().getEFactoryInstance(); }
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"); }
/** * Validates the ItemType constraint of '<em>Name List</em>'. * <!-- begin-user-doc --> * <!-- end-user-doc --> * @generated */ public boolean validateNameList_ItemType(List<?> nameList, DiagnosticChain diagnostics, Map<Object, Object> context) { boolean result = true; for (Iterator<?> i = nameList.iterator(); i.hasNext() && (result || diagnostics != null); ) { Object item = i.next(); if (XMLTypePackage.Literals.NAME.isInstance(item)) { result &= xmlTypeValidator.validateName((String)item, diagnostics, context); } else { result = false; reportDataValueTypeViolation(XMLTypePackage.Literals.NAME, item, diagnostics, context); } } return result; }
@Override public Object caseEDataType(EDataType eDataType) { try { eDataType.getInstanceClass(); } catch (Exception e) { eDataType .setInstanceClassName(EcorePackage.Literals.ESTRING .getInstanceClassName()); } return eDataType; }
public EDataType basicGetBaseType(EDataType eDataType) { EAnnotation eAnnotation = getAnnotation(eDataType, false); if (eAnnotation != null) { EMap<String, String> details = eAnnotation.getDetails(); String baseType = details.get("baseType"); EClassifier type = getEClassifier(eDataType.getEPackage(), baseType); if (type instanceof EDataType) { return (EDataType)type; } } return null; }
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); }
/** * @since 2.8 */ public static EDataType.Internal.ConversionDelegate.Factory getConversionDelegateFactory(EDataType eDataType) { for (String eDataTypeDelegate : getConversionDelegates(eDataType.getEPackage())) { if (eDataType.getEAnnotation(eDataTypeDelegate) != null) { return EDataType.Internal.ConversionDelegate.Factory.Registry.INSTANCE.getFactory(eDataTypeDelegate); } } return null; }
/** * <!-- begin-user-doc --> * <!-- end-user-doc --> * @generated */ public String convertTimeDurationTypeToString(EDataType eDataType, Object instanceValue) { if (instanceValue == null) return null; if (XMLTypePackage.Literals.DURATION.isInstance(instanceValue)) { try { String value = XMLTypeFactory.eINSTANCE.convertToString(XMLTypePackage.Literals.DURATION, instanceValue); if (value != null) return value; } catch (Exception e) { // Keep trying other member types until all have failed. } } if (XMLTypePackage.Literals.DECIMAL.isInstance(instanceValue)) { try { String value = XMLTypeFactory.eINSTANCE.convertToString(XMLTypePackage.Literals.DECIMAL, instanceValue); if (value != null) return value; } catch (Exception e) { // Keep trying other member types until all have failed. } } throw new IllegalArgumentException("Invalid value: '"+instanceValue+"' for datatype :"+eDataType.getName()); }
/** * <!-- begin-user-doc --> * <!-- end-user-doc --> * @generated */ public ResultType createResultTypeFromString(EDataType eDataType, String initialValue) { ResultType result = ResultType.get(initialValue); if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'"); return result; }
jg.writeFieldName(fieldName); if (dataType.getEPackage() == EcorePackage.eINSTANCE) { switch (dataType.getClassifierID()) { case EcorePackage.EBOOLEAN: jg.writeBoolean((Boolean)value); dataType.getEPackage().getEFactoryInstance().convertToString(dataType, value));
/** * Creates an instance of the datatype. * @param eDataType the datatype to instantiate. * @param literal the string value of the datatype. * @return an instance of the datatype. * @see #convertToString(EDataType, Object) */ public static Object createFromString(EDataType eDataType, String literal) { return eDataType.getEPackage().getEFactoryInstance().createFromString(eDataType, literal); }
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"); }
/** * Validates the ItemType constraint of '<em>Type Names List Type</em>'. * <!-- begin-user-doc --> * <!-- end-user-doc --> * @generated */ public boolean validateTypeNamesListType_ItemType(List<?> typeNamesListType, DiagnosticChain diagnostics, Map<Object, Object> context) { boolean result = true; for (Iterator<?> i = typeNamesListType.iterator(); i.hasNext() && (result || diagnostics != null); ) { Object item = i.next(); if (Fes20Package.Literals.TYPE_NAMES_TYPE.isInstance(item)) { result &= validateTypeNamesType(item, diagnostics, context); } else { result = false; reportDataValueTypeViolation(Fes20Package.Literals.TYPE_NAMES_TYPE, item, diagnostics, context); } } return result; }
protected EDataType basicGetItemType(EDataType eDataType) { EAnnotation eAnnotation = getAnnotation(eDataType, false); if (eAnnotation != null) { EMap<String, String> details = eAnnotation.getDetails(); String itemType = details.get("itemType"); EClassifier type = getEClassifier(eDataType.getEPackage(), itemType); if (type instanceof EDataType) { return (EDataType)type; } } return null; }
/** * @since 2.8 */ public static EDataType.Internal.ConversionDelegate.Factory getConversionDelegateFactory(EDataType eDataType) { for (String eDataTypeDelegate : getConversionDelegates(eDataType.getEPackage())) { if (eDataType.getEAnnotation(eDataTypeDelegate) != null) { return EDataType.Internal.ConversionDelegate.Factory.Registry.INSTANCE.getFactory(eDataTypeDelegate); } } return null; }