/**
* 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");
}
}
