/** * Get the value of the named AD parameter for the activity as a string. Works with several types, * not just strings -- enums, for example. * * @param element * @param parameterName * @return null if the parameter is not found */ public static String getParameterString(EPlanElement element, String parameterName) { EObject data = element.getData(); if (data == null) return null; EStructuralFeature feature; try { feature = getParameterFeature(data, parameterName); } catch (UndefinedParameterException e) { return null; } Object object = data.eGet(feature); if (object instanceof EEnumLiteral) { EEnumLiteral literal = (EEnumLiteral) object; return literal.getName(); } EClassifier type = feature.getEType(); if (type instanceof EDataType) { EDataType dataType = (EDataType) type; EPackage typePackage = dataType.getEPackage(); EFactory factory = typePackage.getEFactoryInstance(); String string = factory.convertToString(dataType, object); return string; } LogUtil.warnOnce("feature type '" + type + "'is not EDataType: " + parameterName); return String.valueOf(object); }
/** * Converts a primitive type value, this implementation only converts an EEnum to an Enum value. * * @param value the value to convert * @param eDataType its EDataType * @return the converted value */ @SuppressWarnings({"unchecked", "rawtypes"}) protected Object convertEAttributeValue(final Object value, final EDataType eDataType) { if (value instanceof Enum<?>) { final EDataType enumDataType = getDataTypeOrBaseType(eDataType); Check.isInstanceOf(enumDataType, EEnum.class); final ModelPackage modelPackage = ModelResolver.getInstance().getModelPackage(enumDataType.getEPackage().getNsURI()); final Class<? extends Enum> enumClass = (Class<? extends Enum>) modelPackage.getEClassifierClass(enumDataType); return Enum.valueOf(enumClass, ((Enum<?>) value).name().toUpperCase(Locale.ENGLISH)); } else if (value instanceof EEnumLiteral) { final EDataType enumDataType = getDataTypeOrBaseType(eDataType); Check.isInstanceOf(enumDataType, EEnum.class); final EEnumLiteral eeNumLiteral = (EEnumLiteral) value; final ModelPackage modelPackage = ModelResolver.getInstance().getModelPackage(enumDataType.getEPackage().getNsURI()); if (modelPackage == null) { // dynamic model return eeNumLiteral; } final Class<? extends Enum> enumClass = (Class<? extends Enum>) modelPackage.getEClassifierClass(enumDataType); return Enum.valueOf(enumClass, eeNumLiteral.getName().toUpperCase(Locale.ENGLISH)); } // convert these to a Date always if (value instanceof XMLGregorianCalendar) { final XMLGregorianCalendar xmlCalendar = (XMLGregorianCalendar) value; final Date date = xmlCalendar.toGregorianCalendar().getTime(); return date; } return value; }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ @Override public String convertToString(EDataType eDataType, Object instanceValue) { switch (eDataType.getClassifierID()) { case DataPackage.ATTRIBUTE_SEMANTIC: return convertAttributeSemanticToString(eDataType, instanceValue); case DataPackage.INPUT_METHOD: return convertInputMethodToString(eDataType, instanceValue); case DataPackage.STATUS_MASK: return convertStatusMaskToString(eDataType, instanceValue); case DataPackage.LOOKUP_KEY: return convertLookupKeyToString(eDataType, instanceValue); case DataPackage.CRUD_REPOSITORY: return convertCrudRepositoryToString(eDataType, instanceValue); case DataPackage.PAGING_AND_SORTING_REPOSITORY: return convertPagingAndSortingRepositoryToString(eDataType, instanceValue); case DataPackage.CRUD_REPOSITORY_BASE: return convertCrudRepositoryBaseToString(eDataType, instanceValue); case DataPackage.MEASURE: return convertMeasureToString(eDataType, instanceValue); case DataPackage.PAGEABLE: return convertPageableToString(eDataType, instanceValue); default: throw new IllegalArgumentException( "The datatype '" + eDataType.getName() + "' is not a valid classifier"); } }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ @Override public Object createFromString(EDataType eDataType, String initialValue) { switch (eDataType.getClassifierID()) { case DataPackage.ATTRIBUTE_SEMANTIC: return createAttributeSemanticFromString(eDataType, initialValue); case DataPackage.INPUT_METHOD: return createInputMethodFromString(eDataType, initialValue); case DataPackage.STATUS_MASK: return createStatusMaskFromString(eDataType, initialValue); case DataPackage.LOOKUP_KEY: return createLookupKeyFromString(eDataType, initialValue); case DataPackage.CRUD_REPOSITORY: return createCrudRepositoryFromString(eDataType, initialValue); case DataPackage.PAGING_AND_SORTING_REPOSITORY: return createPagingAndSortingRepositoryFromString(eDataType, initialValue); case DataPackage.CRUD_REPOSITORY_BASE: return createCrudRepositoryBaseFromString(eDataType, initialValue); case DataPackage.MEASURE: return createMeasureFromString(eDataType, initialValue); case DataPackage.PAGEABLE: return createPageableFromString(eDataType, initialValue); default: throw new IllegalArgumentException( "The datatype '" + eDataType.getName() + "' is not a valid classifier"); } }
/** * Expression may return number value which is not directly compatible with feature type (e.g. * Double when Integer is expected), or EEnumLiteral meta-object when literal instance is expected * * @generated */ public static Object performCast(Object value, EDataType targetType) { if (targetType instanceof EEnum) { if (value instanceof EEnumLiteral) { EEnumLiteral literal = (EEnumLiteral) value; return (literal.getInstance() != null) ? literal.getInstance() : literal; } } if (false == value instanceof Number || targetType == null || targetType.getInstanceClass() == null) { return value; } Class<?> targetClass = targetType.getInstanceClass(); Number num = (Number) value; Class<?> valClass = value.getClass(); Class<?> targetWrapperClass = targetClass; if (targetClass.isPrimitive()) { targetWrapperClass = EcoreUtil.wrapperClassFor(targetClass); } if (valClass.equals(targetWrapperClass)) { return value; } if (Number.class.isAssignableFrom(targetWrapperClass)) { if (targetWrapperClass.equals(Byte.class)) return new Byte(num.byteValue()); if (targetWrapperClass.equals(Integer.class)) return new Integer(num.intValue()); if (targetWrapperClass.equals(Short.class)) return new Short(num.shortValue()); if (targetWrapperClass.equals(Long.class)) return new Long(num.longValue()); if (targetWrapperClass.equals(BigInteger.class)) return BigInteger.valueOf(num.longValue()); if (targetWrapperClass.equals(Float.class)) return new Float(num.floatValue()); if (targetWrapperClass.equals(Double.class)) return new Double(num.doubleValue()); if (targetWrapperClass.equals(BigDecimal.class)) return new BigDecimal(num.doubleValue()); } return value; }
/** * {@inheritDoc} * * @see * org.eclipse.emfforms.spi.spreadsheet.core.converter.EMFFormsSpreadsheetValueConverter#setCellValue(org.apache.poi.ss.usermodel.Cell, * java.lang.Object, org.eclipse.emf.ecore.EStructuralFeature, * org.eclipse.emf.ecp.view.spi.context.ViewModelContext) */ @Override public void setCellValue( Cell cell, Object fromObject, EStructuralFeature eStructuralFeature, ViewModelContext viewModelContext) throws EMFFormsConverterException { final EDataType eDataType = EAttribute.class.cast(eStructuralFeature).getEAttributeType(); final EFactory eFactory = eDataType.getEPackage().getEFactoryInstance(); final StringBuilder result = new StringBuilder(); for (final Object value : (List<?>) fromObject) { if (result.length() != 0) { result.append(SEPARATOR); } result.append(eFactory.convertToString(eDataType, value)); } String valueString = result.toString(); if (isDecimalNumber(eDataType.getInstanceClass())) { valueString = valueString.replace( '.', DecimalFormatSymbols.getInstance(localeProvider.getLocale()).getDecimalSeparator()); } cell.setCellValue(valueString); cell.setCellStyle( (CellStyle) viewModelContext.getContextValue(EMFFormsCellStyleConstants.TEXT)); }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ @Override public String convertToString(EDataType eDataType, Object instanceValue) { switch (eDataType.getClassifierID()) { case HwPhysicalPackage.DUMMY: return convertdummyToString(eDataType, instanceValue); default: throw new IllegalArgumentException( "The datatype '" + eDataType.getName() + "' is not a valid classifier"); } }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ @Override public Object createFromString(EDataType eDataType, String initialValue) { switch (eDataType.getClassifierID()) { case HwPhysicalPackage.DUMMY: return createdummyFromString(eDataType, initialValue); default: throw new IllegalArgumentException( "The datatype '" + eDataType.getName() + "' is not a valid classifier"); } }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ @Override public Object createFromString(EDataType eDataType, String initialValue) { switch (eDataType.getClassifierID()) { case MAVOPackage.MAY_DECISION_LOGIC: return createMayDecisionLogicFromString(eDataType, initialValue); default: throw new IllegalArgumentException( "The datatype '" + eDataType.getName() + "' is not a valid classifier"); } }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ @Override public Object createFromString(EDataType eDataType, String initialValue) { switch (eDataType.getClassifierID()) { default: throw new IllegalArgumentException( "The datatype '" + eDataType.getName() + "' is not a valid classifier"); //$NON-NLS-1$ //$NON-NLS-2$ } }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ @Override public String convertToString(EDataType eDataType, Object instanceValue) { switch (eDataType.getClassifierID()) { case DslPatternsPackage.FEATURE_KIND: return convertFeatureKindToString(eDataType, instanceValue); default: throw new IllegalArgumentException( "The datatype '" + eDataType.getName() + "' is not a valid classifier"); } }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ @Override public Object createFromString(EDataType eDataType, String initialValue) { switch (eDataType.getClassifierID()) { case ExtlibraryPackage.BOOK_CATEGORY: return createBookCategoryFromString(eDataType, initialValue); default: throw new IllegalArgumentException( "The datatype '" + eDataType.getName() + "' is not a valid classifier"); } }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ @Override public Object createFromString(EDataType eDataType, String initialValue) { switch (eDataType.getClassifierID()) { case DynamicsPackage.INSTANCE_ACTION: return createInstanceActionFromString(eDataType, initialValue); default: throw new IllegalArgumentException( "The datatype '" + eDataType.getName() + "' is not a valid classifier"); } }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ @Override public String convertToString(EDataType eDataType, Object instanceValue) { switch (eDataType.getClassifierID()) { case PatternPackage.EXPRESSION_TYPE: return convertExpressionTypeToString(eDataType, instanceValue); default: throw new IllegalArgumentException( "The datatype '" + eDataType.getName() + "' is not a valid classifier"); } }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ @Override public String convertToString(EDataType eDataType, Object instanceValue) { switch (eDataType.getClassifierID()) { case DataMapperPackage.SCHEMA_DATA_TYPE: return convertSchemaDataTypeToString(eDataType, instanceValue); default: throw new IllegalArgumentException( "The datatype '" + eDataType.getName() + "' is not a valid classifier"); } }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ @Override public Object createFromString(EDataType eDataType, String initialValue) { switch (eDataType.getClassifierID()) { case DataMapperPackage.SCHEMA_DATA_TYPE: return createSchemaDataTypeFromString(eDataType, initialValue); default: throw new IllegalArgumentException( "The datatype '" + eDataType.getName() + "' is not a valid classifier"); } }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ @Override public String convertToString(EDataType eDataType, Object instanceValue) { switch (eDataType.getClassifierID()) { case RuntimePackage.ZUSTAND: return convertZustandToString(eDataType, instanceValue); default: throw new IllegalArgumentException( "The datatype '" + eDataType.getName() + "' is not a valid classifier"); } }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ @Override public Object createFromString(EDataType eDataType, String initialValue) { switch (eDataType.getClassifierID()) { case RuntimePackage.ZUSTAND: return createZustandFromString(eDataType, initialValue); default: throw new IllegalArgumentException( "The datatype '" + eDataType.getName() + "' is not a valid classifier"); } }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ @Override public String convertToString(EDataType eDataType, Object instanceValue) { switch (eDataType.getClassifierID()) { case DynamicsPackage.INSTANCE_ACTION: return convertInstanceActionToString(eDataType, instanceValue); default: throw new IllegalArgumentException( "The datatype '" + eDataType.getName() + "' is not a valid classifier"); } }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ @Override public Object createFromString(EDataType eDataType, String initialValue) { switch (eDataType.getClassifierID()) { case PatternPackage.EXPRESSION_TYPE: return createExpressionTypeFromString(eDataType, initialValue); default: throw new IllegalArgumentException( "The datatype '" + eDataType.getName() + "' is not a valid classifier"); } }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ @Override public Object createFromString(EDataType eDataType, String initialValue) { switch (eDataType.getClassifierID()) { case GenericsPackage.MY_NUMBER: return createMyNumberFromString(eDataType, initialValue); default: throw new IllegalArgumentException( "The datatype '" + eDataType.getName() + "' is not a valid classifier"); } }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ @Override public Object createFromString(EDataType eDataType, String initialValue) { switch (eDataType.getClassifierID()) { case HiddentokenmergertestPackage.ENUM_BUG_ENUM: return createEnumBugEnumFromString(eDataType, initialValue); default: throw new IllegalArgumentException( "The datatype '" + eDataType.getName() + "' is not a valid classifier"); } }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ @Override public String convertToString(EDataType eDataType, Object instanceValue) { switch (eDataType.getClassifierID()) { case ExtlibraryPackage.BOOK_CATEGORY: return convertBookCategoryToString(eDataType, instanceValue); default: throw new IllegalArgumentException( "The datatype '" + eDataType.getName() + "' is not a valid classifier"); } }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ @Override public Object createFromString(EDataType eDataType, String initialValue) { switch (eDataType.getClassifierID()) { case DslPatternsPackage.FEATURE_KIND: return createFeatureKindFromString(eDataType, initialValue); default: throw new IllegalArgumentException( "The datatype '" + eDataType.getName() + "' is not a valid classifier"); } }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ @Override public String convertToString(EDataType eDataType, Object instanceValue) { switch (eDataType.getClassifierID()) { case GenericsPackage.MY_NUMBER: return convertMyNumberToString(eDataType, instanceValue); default: throw new IllegalArgumentException( "The datatype '" + eDataType.getName() + "' is not a valid classifier"); } }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ @Override public Object createFromString(EDataType eDataType, String initialValue) { switch (eDataType.getClassifierID()) { case XsdPackage.ATT_USE_TYPE: return createAttUseTypeFromString(eDataType, initialValue); default: throw new IllegalArgumentException( "The datatype '" + eDataType.getName() + "' is not a valid classifier"); } }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ @Override public String convertToString(EDataType eDataType, Object instanceValue) { switch (eDataType.getClassifierID()) { case HiddentokenmergertestPackage.ENUM_BUG_ENUM: return convertEnumBugEnumToString(eDataType, instanceValue); default: throw new IllegalArgumentException( "The datatype '" + eDataType.getName() + "' is not a valid classifier"); } }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ @Override public String convertToString(EDataType eDataType, Object instanceValue) { switch (eDataType.getClassifierID()) { case XsdPackage.ATT_USE_TYPE: return convertAttUseTypeToString(eDataType, instanceValue); default: throw new IllegalArgumentException( "The datatype '" + eDataType.getName() + "' is not a valid classifier"); } }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ @Override public String convertToString(EDataType eDataType, Object instanceValue) { switch (eDataType.getClassifierID()) { default: throw new IllegalArgumentException( "The datatype '" + eDataType.getName() + "' is not a valid classifier"); //$NON-NLS-1$ //$NON-NLS-2$ } }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ @Override public String convertToString(EDataType eDataType, Object instanceValue) { switch (eDataType.getClassifierID()) { case MAVOPackage.MAY_DECISION_LOGIC: return convertMayDecisionLogicToString(eDataType, instanceValue); default: throw new IllegalArgumentException( "The datatype '" + eDataType.getName() + "' is not a valid classifier"); } }