| /** |
| ******************************************************************************** |
| * Copyright (c) 2015-2020 Robert Bosch GmbH and others. |
| * |
| * This program and the accompanying materials are made |
| * available under the terms of the Eclipse Public License 2.0 |
| * which is available at https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * Robert Bosch GmbH - initial API and implementation |
| ******************************************************************************** |
| */ |
| |
| package org.eclipse.app4mc.amalthea.model.provider |
| |
| import java.util.ArrayList |
| import java.util.List |
| import java.util.Map |
| import org.apache.commons.lang.StringUtils |
| import org.eclipse.app4mc.amalthea.model.AbstractElementMappingConstraint |
| import org.eclipse.app4mc.amalthea.model.AccessPrecedenceSpec |
| import org.eclipse.app4mc.amalthea.model.AccessPrecedenceType |
| import org.eclipse.app4mc.amalthea.model.Alias |
| import org.eclipse.app4mc.amalthea.model.Amalthea |
| import org.eclipse.app4mc.amalthea.model.AmaltheaPackage |
| import org.eclipse.app4mc.amalthea.model.ArchitectureRequirement |
| import org.eclipse.app4mc.amalthea.model.ArrivalCurveEntry |
| import org.eclipse.app4mc.amalthea.model.AsynchronousServerCall |
| import org.eclipse.app4mc.amalthea.model.BaseTypeDefinition |
| import org.eclipse.app4mc.amalthea.model.BigIntegerObject |
| import org.eclipse.app4mc.amalthea.model.BlockingType |
| import org.eclipse.app4mc.amalthea.model.BooleanObject |
| import org.eclipse.app4mc.amalthea.model.CPUPercentageMetric |
| import org.eclipse.app4mc.amalthea.model.CPUPercentageRequirementLimit |
| import org.eclipse.app4mc.amalthea.model.CallArgument |
| import org.eclipse.app4mc.amalthea.model.ChainedProcessPrototype |
| import org.eclipse.app4mc.amalthea.model.ChannelAccess |
| import org.eclipse.app4mc.amalthea.model.ChannelReceive |
| import org.eclipse.app4mc.amalthea.model.ChannelSend |
| import org.eclipse.app4mc.amalthea.model.ClearEvent |
| import org.eclipse.app4mc.amalthea.model.CoherencyDirection |
| import org.eclipse.app4mc.amalthea.model.Component |
| import org.eclipse.app4mc.amalthea.model.ComponentInstance |
| import org.eclipse.app4mc.amalthea.model.ComponentPort |
| import org.eclipse.app4mc.amalthea.model.ComponentScope |
| import org.eclipse.app4mc.amalthea.model.ComponentStructure |
| import org.eclipse.app4mc.amalthea.model.Composite |
| import org.eclipse.app4mc.amalthea.model.Condition |
| import org.eclipse.app4mc.amalthea.model.Connector |
| import org.eclipse.app4mc.amalthea.model.CoreClassification |
| import org.eclipse.app4mc.amalthea.model.CountMetric |
| import org.eclipse.app4mc.amalthea.model.CountRequirementLimit |
| import org.eclipse.app4mc.amalthea.model.CustomEventTrigger |
| import org.eclipse.app4mc.amalthea.model.DataAgeCycle |
| import org.eclipse.app4mc.amalthea.model.DataAgeTime |
| import org.eclipse.app4mc.amalthea.model.DataCoherencyGroup |
| import org.eclipse.app4mc.amalthea.model.DataRate |
| import org.eclipse.app4mc.amalthea.model.DataRateUnit |
| import org.eclipse.app4mc.amalthea.model.DataSize |
| import org.eclipse.app4mc.amalthea.model.DataSizeUnit |
| import org.eclipse.app4mc.amalthea.model.DataStability |
| import org.eclipse.app4mc.amalthea.model.DataTypeDefinition |
| import org.eclipse.app4mc.amalthea.model.DirectionType |
| import org.eclipse.app4mc.amalthea.model.DoubleObject |
| import org.eclipse.app4mc.amalthea.model.EventChainContainer |
| import org.eclipse.app4mc.amalthea.model.EventChainMeasurement |
| import org.eclipse.app4mc.amalthea.model.EventChainReference |
| import org.eclipse.app4mc.amalthea.model.EventConfig |
| import org.eclipse.app4mc.amalthea.model.FloatObject |
| import org.eclipse.app4mc.amalthea.model.Frequency |
| import org.eclipse.app4mc.amalthea.model.FrequencyMetric |
| import org.eclipse.app4mc.amalthea.model.FrequencyRequirementLimit |
| import org.eclipse.app4mc.amalthea.model.FrequencyUnit |
| import org.eclipse.app4mc.amalthea.model.GetResultServerCall |
| import org.eclipse.app4mc.amalthea.model.Group |
| import org.eclipse.app4mc.amalthea.model.GroupingType |
| import org.eclipse.app4mc.amalthea.model.HwAccessElement |
| import org.eclipse.app4mc.amalthea.model.HwAccessPath |
| import org.eclipse.app4mc.amalthea.model.HwConnection |
| import org.eclipse.app4mc.amalthea.model.HwFeature |
| import org.eclipse.app4mc.amalthea.model.HwFeatureCategory |
| import org.eclipse.app4mc.amalthea.model.HwPort |
| import org.eclipse.app4mc.amalthea.model.HwStructure |
| import org.eclipse.app4mc.amalthea.model.INamed |
| import org.eclipse.app4mc.amalthea.model.ISRAllocation |
| import org.eclipse.app4mc.amalthea.model.IntegerObject |
| import org.eclipse.app4mc.amalthea.model.InterProcessTrigger |
| import org.eclipse.app4mc.amalthea.model.InterfaceKind |
| import org.eclipse.app4mc.amalthea.model.LabelAccess |
| import org.eclipse.app4mc.amalthea.model.LabelAccessEnum |
| import org.eclipse.app4mc.amalthea.model.LimitType |
| import org.eclipse.app4mc.amalthea.model.ListObject |
| import org.eclipse.app4mc.amalthea.model.LongObject |
| import org.eclipse.app4mc.amalthea.model.MainInterface |
| import org.eclipse.app4mc.amalthea.model.MemoryClassification |
| import org.eclipse.app4mc.amalthea.model.MemoryMapping |
| import org.eclipse.app4mc.amalthea.model.MinAvgMaxStatistic |
| import org.eclipse.app4mc.amalthea.model.ModeAssignment |
| import org.eclipse.app4mc.amalthea.model.ModeConditionConjunction |
| import org.eclipse.app4mc.amalthea.model.ModeConditionDisjunction |
| import org.eclipse.app4mc.amalthea.model.ModeLabel |
| import org.eclipse.app4mc.amalthea.model.ModeLabelAccess |
| import org.eclipse.app4mc.amalthea.model.ModeLabelCondition |
| import org.eclipse.app4mc.amalthea.model.ModeLiteral |
| import org.eclipse.app4mc.amalthea.model.ModeSwitch |
| import org.eclipse.app4mc.amalthea.model.ModeSwitchEntry |
| import org.eclipse.app4mc.amalthea.model.ModeValueCondition |
| import org.eclipse.app4mc.amalthea.model.ModeValueList |
| import org.eclipse.app4mc.amalthea.model.Namespace |
| import org.eclipse.app4mc.amalthea.model.NonAtomicDataCoherency |
| import org.eclipse.app4mc.amalthea.model.OrderPrecedenceSpec |
| import org.eclipse.app4mc.amalthea.model.OrderType |
| import org.eclipse.app4mc.amalthea.model.OsAPIOverhead |
| import org.eclipse.app4mc.amalthea.model.OsDataConsistency |
| import org.eclipse.app4mc.amalthea.model.OsDataConsistencyMode |
| import org.eclipse.app4mc.amalthea.model.OsISROverhead |
| import org.eclipse.app4mc.amalthea.model.OsOverhead |
| import org.eclipse.app4mc.amalthea.model.PercentageMetric |
| import org.eclipse.app4mc.amalthea.model.PercentageRequirementLimit |
| import org.eclipse.app4mc.amalthea.model.PhysicalSectionConstraint |
| import org.eclipse.app4mc.amalthea.model.PhysicalSectionMapping |
| import org.eclipse.app4mc.amalthea.model.ProcessAllocationConstraint |
| import org.eclipse.app4mc.amalthea.model.ProcessChainRequirement |
| import org.eclipse.app4mc.amalthea.model.ProcessPrototypeAllocationConstraint |
| import org.eclipse.app4mc.amalthea.model.ProcessRequirement |
| import org.eclipse.app4mc.amalthea.model.ProcessScope |
| import org.eclipse.app4mc.amalthea.model.QualifiedPort |
| import org.eclipse.app4mc.amalthea.model.ReferenceObject |
| import org.eclipse.app4mc.amalthea.model.RelationalOperator |
| import org.eclipse.app4mc.amalthea.model.RunnableAllocation |
| import org.eclipse.app4mc.amalthea.model.RunnableAllocationConstraint |
| import org.eclipse.app4mc.amalthea.model.RunnableCall |
| import org.eclipse.app4mc.amalthea.model.RunnableMeasurement |
| import org.eclipse.app4mc.amalthea.model.RunnableParameter |
| import org.eclipse.app4mc.amalthea.model.RunnableRequirement |
| import org.eclipse.app4mc.amalthea.model.RunnableScope |
| import org.eclipse.app4mc.amalthea.model.SchedulerAllocation |
| import org.eclipse.app4mc.amalthea.model.SchedulingParameters |
| import org.eclipse.app4mc.amalthea.model.SemaphoreAccess |
| import org.eclipse.app4mc.amalthea.model.SemaphoreAccessEnum |
| import org.eclipse.app4mc.amalthea.model.SenderReceiverRead |
| import org.eclipse.app4mc.amalthea.model.SenderReceiverWrite |
| import org.eclipse.app4mc.amalthea.model.SetEvent |
| import org.eclipse.app4mc.amalthea.model.SingleValueStatistic |
| import org.eclipse.app4mc.amalthea.model.StringObject |
| import org.eclipse.app4mc.amalthea.model.SubEventChain |
| import org.eclipse.app4mc.amalthea.model.SubInterface |
| import org.eclipse.app4mc.amalthea.model.SynchronousServerCall |
| import org.eclipse.app4mc.amalthea.model.TagGroup |
| import org.eclipse.app4mc.amalthea.model.TaskAllocation |
| import org.eclipse.app4mc.amalthea.model.TaskMeasurement |
| import org.eclipse.app4mc.amalthea.model.Ticks |
| import org.eclipse.app4mc.amalthea.model.Time |
| import org.eclipse.app4mc.amalthea.model.TimeMetric |
| import org.eclipse.app4mc.amalthea.model.TimeRequirementLimit |
| import org.eclipse.app4mc.amalthea.model.TimeUnit |
| import org.eclipse.app4mc.amalthea.model.TransmissionPolicy |
| import org.eclipse.app4mc.amalthea.model.TypeRef |
| import org.eclipse.app4mc.amalthea.model.Value |
| import org.eclipse.app4mc.amalthea.model.Voltage |
| import org.eclipse.app4mc.amalthea.model.VoltageUnit |
| import org.eclipse.app4mc.amalthea.model.WaitEvent |
| import org.eclipse.app4mc.amalthea.model.WaitingBehaviour |
| import org.eclipse.app4mc.amalthea.model.impl.CustomPropertyImpl |
| import org.eclipse.app4mc.amalthea.model.impl.InterfaceChannelImpl |
| import org.eclipse.app4mc.amalthea.model.impl.NeedEntryImpl |
| import org.eclipse.app4mc.amalthea.model.impl.TicksEntryImpl |
| import org.eclipse.emf.common.notify.AdapterFactory |
| import org.eclipse.emf.common.notify.Notification |
| import org.eclipse.emf.ecore.EObject |
| import org.eclipse.emf.edit.provider.IItemLabelProvider |
| import org.eclipse.emf.edit.provider.ViewerNotification |
| |
| class CustomItemProviderService { |
| |
| private def static getContainingFeatureName(EObject object, String defaultText, String separator) { |
| val feature = object?.eContainingFeature() |
| val name = if(feature === null) defaultText else feature.name + separator |
| return name |
| } |
| |
| private def static getContainingFeatureName(EObject object) { |
| return getContainingFeatureName(object, "", ": ") |
| } |
| |
| private def static addParentLabelNotification(List<ViewerNotification> list, Notification notification) { |
| addParentLabelNotification(list, notification, 1) |
| } |
| |
| private def static addParentLabelNotification(List<ViewerNotification> list, Notification notification, int number) { |
| var obj = notification.getNotifier() as EObject |
| var i = 0 |
| while ((i=i+1) <= number && (obj=obj.eContainer) !== null) { |
| list.add(0, new ViewerNotification(notification, obj, false, true)) |
| } |
| } |
| |
| private def static getLabelProviderText(Object object, AdapterFactory rootAF) { |
| if (object !== null && rootAF.isFactoryForType(object)) { |
| val plainAdapter = rootAF.adapt(object, typeof(IItemLabelProvider)) |
| if (plainAdapter instanceof IItemLabelProvider) { |
| return plainAdapter.getText(object) |
| } |
| } |
| return "" |
| } |
| |
| /* Pretty print methods */ |
| private def static ppCamelCase(String s) { |
| StringUtils.join(StringUtils.splitByCharacterTypeCamelCase(s), ' ') |
| } |
| |
| private def static ppName(String name) { |
| return ppName(name, "???") |
| } |
| |
| private def static ppName(String name, String surrogate) { |
| if(name.isNullOrEmpty) return surrogate |
| return name |
| } |
| |
| ///// |
| ///// _________________________ Amalthea _________________________ |
| ///// |
| |
| /***************************************************************************** |
| * AmaltheaItemProvider |
| *****************************************************************************/ |
| def static String getAmaltheaItemProviderText(Object object, String defaultText) { |
| if (object instanceof Amalthea) { |
| return "AMALTHEA model (version " + object.version + ")" |
| } else { |
| return defaultText |
| } |
| } |
| |
| ///// |
| ///// _________________________ Common _________________________ |
| ///// |
| |
| private def static getTimeText(Time time) { |
| if(time === null) return "<time>" |
| |
| val value = if(time.value === null) "???" else time.value.toString |
| val unit = if(time.unit == TimeUnit::_UNDEFINED_) "<unit>" else time.unit.literal |
| return value + " " + unit |
| } |
| |
| private def static getDataSizeText(DataSize size) { |
| if(size === null) return "<data size>" |
| |
| val value = if(size.value === null) "???" else size.value.toString |
| val unit = if(size.unit == DataSizeUnit::_UNDEFINED_) "<unit>" else size.unit.literal |
| return value + " " + unit |
| } |
| |
| private def static getDataRateText(DataRate rate) { |
| if(rate === null) return "<data rate>" |
| |
| val value = if(rate.value === null) "???" else rate.value.toString |
| val unit = if(rate.unit == DataRateUnit::_UNDEFINED_) "<unit>" else rate.unit.literal |
| return value + " " + unit.replace("PerSecond", "/s") |
| } |
| |
| private def static getFrequencyText(Frequency frequency) { |
| if(frequency === null) return "<frequency>" |
| |
| val value = Double.toString(frequency.value) |
| val unit = if(frequency.unit == FrequencyUnit::_UNDEFINED_) "<unit>" else frequency.unit.literal |
| return value + " " + unit |
| } |
| |
| private def static getVoltageText(Voltage voltage) { |
| if(voltage === null) return "<voltage>" |
| |
| val value = Double.toString(voltage.value) |
| val unit = if(voltage.unit == VoltageUnit::_UNDEFINED_) "<unit>" else voltage.unit.literal |
| return value + " " + unit |
| } |
| |
| private def static getDeviationBoundText(Object bound) { |
| switch bound { |
| LongObject: |
| String.valueOf(bound.value) |
| DoubleObject: |
| String.valueOf(bound.value) |
| Time: |
| getTimeText(bound) |
| } |
| } |
| |
| private def static trimDistName(String name) { |
| if (name === null) return "" |
| |
| return name.replace("Distribution", "").replace("Estimators", "").replace("Parameters", "") |
| } |
| |
| private def static trimMultilineString(String text) { |
| if (text.nullOrEmpty) return "???" |
| |
| val charArray = text.toCharArray() |
| for (var i = 0; i < charArray.length; i++) { |
| if (Character.isISOControl(charArray.get(i))) { |
| return text.substring(0, i) + "..."; |
| } |
| } |
| |
| return text; |
| } |
| |
| private def static getValueText(Value object) { |
| if(object === null) return "null" |
| |
| switch object { |
| BooleanObject: |
| String.valueOf(object.value) |
| IntegerObject: |
| String.valueOf(object.value) |
| LongObject: |
| String.valueOf(object.value) |
| BigIntegerObject: |
| String.valueOf(object.value) |
| FloatObject: |
| String.valueOf(object.value) |
| DoubleObject: |
| String.valueOf(object.value) |
| StringObject: |
| if(object.value === null) "null" else "\"" + trimMultilineString(object.value) + "\"" |
| ReferenceObject: |
| if(object.value === null) "null" else object.value.eClass.name + " \"" + ppName(object?.value?.name) + "\"" |
| Time: |
| if(object.value === null) "null" else getTimeText(object) |
| ListObject: |
| "List" |
| } |
| } |
| |
| |
| /***************************************************************************** |
| * CustomPropertyItemProvider |
| *****************************************************************************/ |
| def static String getCustomPropertyItemProviderText(Object object, String defaultText) { |
| if (object instanceof CustomPropertyImpl) { |
| val key = object?.getKey() |
| val value = object?.getValue() |
| val valueType = object?.getValue()?.eClass?.name |
| val s1 = if(key.isNullOrEmpty) "<key>" else "\"" + key + "\"" |
| val s2 = if(valueType === null) "" else "(" + valueType.replace("Object", "") + ") " |
| val s3 = getValueText(value) |
| return s1 + " -> " + s2 + s3; |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getCustomPropertyItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(Map.Entry)) { |
| case AmaltheaPackage::CUSTOM_PROPERTY__KEY: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| case AmaltheaPackage::CUSTOM_PROPERTY__VALUE: |
| return new ViewerNotification(notification, notification.getNotifier(), true, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * BooleanObjectItemProvider |
| *****************************************************************************/ |
| def static String getBooleanObjectItemProviderText(Object object, String defaultText) { |
| if (object instanceof BooleanObject) { |
| return getContainingFeatureName(object) + getValueText(object) |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static List<ViewerNotification> getBooleanObjectItemProviderNotifications(Notification notification) { |
| val list = newArrayList |
| switch notification.getFeatureID(typeof(BooleanObject)) { |
| case AmaltheaPackage::BOOLEAN_OBJECT__VALUE: { |
| list.add(new ViewerNotification(notification, notification.getNotifier(), false, true)) |
| addParentLabelNotification(list, notification) |
| } |
| } |
| return list |
| } |
| |
| /***************************************************************************** |
| * DoubleObjectItemProvider |
| *****************************************************************************/ |
| def static String getDoubleObjectItemProviderText(Object object, String defaultText) { |
| if (object instanceof DoubleObject) { |
| return getContainingFeatureName(object) + getValueText(object) |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static List<ViewerNotification> getDoubleObjectItemProviderNotifications(Notification notification) { |
| val list = newArrayList |
| switch notification.getFeatureID(typeof(DoubleObject)) { |
| case AmaltheaPackage::DOUBLE_OBJECT__VALUE: { |
| list.add(new ViewerNotification(notification, notification.getNotifier(), false, true)) |
| addParentLabelNotification(list, notification) |
| } |
| } |
| return list |
| } |
| |
| /***************************************************************************** |
| * FloatObjectItemProvider |
| *****************************************************************************/ |
| def static String getFloatObjectItemProviderText(Object object, String defaultText) { |
| if (object instanceof FloatObject) { |
| return getContainingFeatureName(object) + getValueText(object) |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static List<ViewerNotification> getFloatObjectItemProviderNotifications(Notification notification) { |
| val list = newArrayList |
| switch notification.getFeatureID(typeof(FloatObject)) { |
| case AmaltheaPackage::FLOAT_OBJECT__VALUE: { |
| list.add(new ViewerNotification(notification, notification.getNotifier(), false, true)) |
| addParentLabelNotification(list, notification) |
| } |
| } |
| return list |
| } |
| |
| /***************************************************************************** |
| * IntegerObjectItemProvider |
| *****************************************************************************/ |
| def static String getIntegerObjectItemProviderText(Object object, String defaultText) { |
| if (object instanceof IntegerObject) { |
| return getContainingFeatureName(object) + getValueText(object) |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static List<ViewerNotification> getIntegerObjectItemProviderNotifications(Notification notification) { |
| val list = newArrayList |
| switch notification.getFeatureID(typeof(IntegerObject)) { |
| case AmaltheaPackage::INTEGER_OBJECT__VALUE: { |
| list.add(new ViewerNotification(notification, notification.getNotifier(), false, true)) |
| addParentLabelNotification(list, notification) |
| } |
| } |
| return list |
| } |
| |
| /***************************************************************************** |
| * LongObjectItemProvider |
| *****************************************************************************/ |
| def static String getLongObjectItemProviderText(Object object, String defaultText) { |
| if (object instanceof LongObject) { |
| return getContainingFeatureName(object) + getValueText(object) |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static List<ViewerNotification> getLongObjectItemProviderNotifications(Notification notification) { |
| val list = newArrayList |
| switch notification.getFeatureID(typeof(LongObject)) { |
| case AmaltheaPackage::LONG_OBJECT__VALUE: { |
| list.add(new ViewerNotification(notification, notification.getNotifier(), false, true)) |
| addParentLabelNotification(list, notification) |
| } |
| } |
| return list |
| } |
| |
| /***************************************************************************** |
| * StringObjectItemProvider |
| *****************************************************************************/ |
| def static String getStringObjectItemProviderText(Object object, String defaultText) { |
| if (object instanceof StringObject) { |
| return getContainingFeatureName(object) + getValueText(object) |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static List<ViewerNotification> getStringObjectItemProviderNotifications(Notification notification) { |
| val list = newArrayList |
| switch notification.getFeatureID(typeof(StringObject)) { |
| case AmaltheaPackage::STRING_OBJECT__VALUE: { |
| list.add(new ViewerNotification(notification, notification.getNotifier(), false, true)) |
| addParentLabelNotification(list, notification) |
| } |
| } |
| return list |
| } |
| |
| /***************************************************************************** |
| * BigIntegerObjectItemProvider |
| *****************************************************************************/ |
| def static String getBigIntegerObjectItemProviderText(Object object, String defaultText) { |
| if (object instanceof BigIntegerObject) { |
| return getContainingFeatureName(object) + getValueText(object) |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static List<ViewerNotification> getBigIntegerObjectItemProviderNotifications(Notification notification) { |
| val list = newArrayList |
| switch notification.getFeatureID(typeof(BigIntegerObject)) { |
| case AmaltheaPackage::BIG_INTEGER_OBJECT__VALUE: { |
| list.add(new ViewerNotification(notification, notification.getNotifier(), false, true)) |
| addParentLabelNotification(list, notification) |
| } |
| } |
| return list |
| } |
| |
| /***************************************************************************** |
| * ReferenceObjectItemProvider |
| *****************************************************************************/ |
| def static String getReferenceObjectItemProviderText(Object object, String defaultText) { |
| if (object instanceof ReferenceObject) { |
| return getContainingFeatureName(object) + getValueText(object) |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static List<ViewerNotification> getReferenceObjectItemProviderNotifications(Notification notification) { |
| val list = newArrayList |
| switch notification.getFeatureID(typeof(ReferenceObject)) { |
| case AmaltheaPackage::REFERENCE_OBJECT__VALUE: { |
| list.add(new ViewerNotification(notification, notification.getNotifier(), false, true)) |
| addParentLabelNotification(list, notification) |
| } |
| } |
| return list |
| } |
| |
| /***************************************************************************** |
| * FrequencyItemProvider |
| *****************************************************************************/ |
| def static String getFrequencyItemProviderText(Object object, String defaultText) { |
| if (object instanceof Frequency) { |
| return getContainingFeatureName(object) + getFrequencyText(object) |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static List<ViewerNotification> getFrequencyItemProviderNotifications(Notification notification) { |
| val list = newArrayList |
| switch notification.getFeatureID(typeof(Frequency)) { |
| case AmaltheaPackage::FREQUENCY__VALUE, |
| case AmaltheaPackage::FREQUENCY__UNIT: { |
| list.add(new ViewerNotification(notification, notification.getNotifier(), false, true)) |
| addParentLabelNotification(list, notification) |
| } |
| } |
| return list |
| } |
| |
| /***************************************************************************** |
| * VoltageItemProvider |
| *****************************************************************************/ |
| def static String getVoltageItemProviderText(Object object, String defaultText) { |
| if (object instanceof Voltage) { |
| return getContainingFeatureName(object) + getVoltageText(object) |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static List<ViewerNotification> getVoltageItemProviderNotifications(Notification notification) { |
| val list = newArrayList |
| switch notification.getFeatureID(typeof(Voltage)) { |
| case AmaltheaPackage::VOLTAGE__VALUE, |
| case AmaltheaPackage::VOLTAGE__UNIT: { |
| list.add(new ViewerNotification(notification, notification.getNotifier(), false, true)) |
| addParentLabelNotification(list, notification) |
| } |
| } |
| return list |
| } |
| |
| /***************************************************************************** |
| * DataSizeItemProvider |
| *****************************************************************************/ |
| def static String getDataSizeItemProviderText(Object object, String defaultText) { |
| if (object instanceof DataSize) { |
| return getContainingFeatureName(object) + getDataSizeText(object) |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static List<ViewerNotification> getDataSizeItemProviderNotifications(Notification notification) { |
| val list = newArrayList |
| switch notification.getFeatureID(typeof(DataSize)) { |
| case AmaltheaPackage::DATA_SIZE__VALUE, |
| case AmaltheaPackage::DATA_SIZE__UNIT: { |
| list.add(new ViewerNotification(notification, notification.getNotifier(), false, true)) |
| addParentLabelNotification(list, notification) |
| } |
| } |
| return list |
| } |
| |
| /***************************************************************************** |
| * DataRateItemProvider |
| *****************************************************************************/ |
| def static String getDataRateItemProviderText(Object object, String defaultText) { |
| if (object instanceof DataRate) { |
| return getContainingFeatureName(object) + getDataRateText(object) |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static List<ViewerNotification> getDataRateItemProviderNotifications(Notification notification) { |
| val list = newArrayList |
| switch notification.getFeatureID(typeof(DataRate)) { |
| case AmaltheaPackage::DATA_RATE__VALUE, |
| case AmaltheaPackage::DATA_RATE__UNIT: { |
| list.add(new ViewerNotification(notification, notification.getNotifier(), false, true)) |
| addParentLabelNotification(list, notification) |
| } |
| } |
| return list |
| } |
| |
| /***************************************************************************** |
| * MinAvgMaxStatisticItemProvider |
| *****************************************************************************/ |
| def static String getMinAvgMaxStatisticItemProviderText(Object object, String defaultText) { |
| if (object instanceof MinAvgMaxStatistic) { |
| val s1 = getContainingFeatureName(object) |
| return s1 + object.min + " : " + object.avg + " : " + object.max |
| } else { |
| return defaultText |
| } |
| } |
| |
| /***************************************************************************** |
| * SingleValueStatisticItemProvider |
| *****************************************************************************/ |
| def static String getSingleValueStatisticItemProviderText(Object object, String defaultText) { |
| if (object instanceof SingleValueStatistic) { |
| return getContainingFeatureName(object) + object.value |
| } else { |
| return defaultText |
| } |
| } |
| |
| /***************************************************************************** |
| * TimeItemProvider |
| *****************************************************************************/ |
| def static String getTimeItemProviderText(Object object, String defaultText) { |
| if (object instanceof Time) { |
| return getContainingFeatureName(object) + getTimeText(object) |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static List<ViewerNotification> getTimeItemProviderNotifications(Notification notification) { |
| val list = newArrayList |
| switch notification.getFeatureID(typeof(Time)) { |
| case AmaltheaPackage::TIME__VALUE, |
| case AmaltheaPackage::TIME__UNIT: { |
| list.add(new ViewerNotification(notification, notification.getNotifier(), false, true)) |
| addParentLabelNotification(list, notification, 2) |
| } |
| } |
| return list |
| } |
| |
| /***************************************************************************** |
| * NamespaceItemProvider |
| *****************************************************************************/ |
| def static String getNamespaceItemProviderText(Object object, String defaultText) { |
| if (object instanceof Namespace) { |
| val longname = object?.qualifiedName |
| return if(longname.isNullOrEmpty) "<namespace>" else "Namespace " + longname |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getNamespaceItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(Namespace)) { |
| case AmaltheaPackage::NAMESPACE__NAME, |
| case AmaltheaPackage::NAMESPACE__QUALIFIED_NAME, |
| case AmaltheaPackage::NAMESPACE__UNIQUE_NAME: |
| return new ViewerNotification(notification, notification.getNotifier(), true, true) |
| case AmaltheaPackage::NAMESPACE__NEXT_SEGMENTS: |
| return new ViewerNotification(notification, notification.getNotifier(), true, false) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * TransmissionPolicyItemProvider |
| *****************************************************************************/ |
| def static String getTransmissionPolicyItemProviderText(Object object, String defaultText) { |
| if (object instanceof TransmissionPolicy) { |
| val size = object.chunkSize |
| val ticks = object.chunkProcessingTicks |
| val ratio = object.transmitRatio |
| |
| return "transmission (chunk size: " + getDataSizeText(size) + " ticks: " + ticks + " ratio: " + ratio + ")"; |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getTransmissionPolicyItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(TransmissionPolicy)) { |
| case AmaltheaPackage::TRANSMISSION_POLICY__CHUNK_PROCESSING_TICKS, |
| case AmaltheaPackage::TRANSMISSION_POLICY__TRANSMIT_RATIO: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| case AmaltheaPackage::TRANSMISSION_POLICY__CHUNK_SIZE: |
| return new ViewerNotification(notification, notification.getNotifier(), true, true) |
| } |
| return null |
| } |
| |
| ///// |
| ///// _________________________ Components _________________________ |
| ///// |
| |
| /***************************************************************************** |
| * ComponentStructureProvider |
| *****************************************************************************/ |
| def static String getComponentStructureItemProviderText(Object object, String defaultText) { |
| if (object instanceof ComponentStructure) { |
| val name = object?.name |
| val typeName = object?.structureType |
| val s1 = ppName(typeName, "") |
| val s2 = if (s1.empty) "" else " " |
| val s3 = ppName(name, "<structure>") |
| return s1 + s2 + s3 |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getComponentStructureItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(ComponentStructure)) { |
| case AmaltheaPackage.COMPONENT_STRUCTURE__STRUCTURE_TYPE, |
| case AmaltheaPackage.COMPONENT_STRUCTURE__NAME: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| case AmaltheaPackage.COMPONENT_STRUCTURE__SUB_STRUCTURES, |
| case AmaltheaPackage.COMPONENT_STRUCTURE__COMPONENTS, |
| case AmaltheaPackage.COMPONENT_STRUCTURE__INTERFACES: |
| return new ViewerNotification(notification, notification.getNotifier(), true, false) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * ComponentItemProvider |
| *****************************************************************************/ |
| def static String getComponentItemProviderText(Object object, String defaultText) { |
| if (object instanceof Component) { |
| val name = object?.qualifiedName |
| |
| return if(name.isNullOrEmpty) "<component>" else "Component " + name |
| } else { |
| return defaultText |
| } |
| } |
| |
| /***************************************************************************** |
| * CompositeItemProvider |
| *****************************************************************************/ |
| def static String getCompositeItemProviderText(Object object, String defaultText) { |
| if (object instanceof Composite) { |
| val name = object?.qualifiedName |
| |
| return if(name.isNullOrEmpty) "<composite>" else "Composite " + name |
| } else { |
| return defaultText |
| } |
| } |
| |
| /***************************************************************************** |
| * ComponentInstanceItemProvider |
| *****************************************************************************/ |
| def static String getComponentInstanceItemProviderText(Object object, String defaultText) { |
| if (object instanceof ComponentInstance) { |
| val name = object?.qualifiedName |
| val typeName = object?.type?.qualifiedName |
| val s1 = ppName(name, "<component instance>") |
| val s2 = ppName(typeName) |
| return s1 + " (type: " + s2 + ")" |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getComponentInstanceItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(ComponentInstance)) { |
| case AmaltheaPackage::COMPONENT_INSTANCE__NAME, |
| case AmaltheaPackage::COMPONENT_INSTANCE__TYPE: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| case AmaltheaPackage::COMPONENT_INSTANCE__CUSTOM_PROPERTIES: |
| return new ViewerNotification(notification, notification.getNotifier(), true, false) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * ConnectorItemProvider |
| *****************************************************************************/ |
| def static String getConnectorItemProviderText(Object object, String defaultText) { |
| if (object instanceof Connector) { |
| val name = object?.name |
| val s1 = ppName(name, "<connector>") |
| return s1 |
| } else { |
| return defaultText |
| } |
| } |
| |
| /***************************************************************************** |
| * ComponentPortItemProvider |
| *****************************************************************************/ |
| def static String getComponentPortItemProviderText(Object object, String defaultText) { |
| if (object instanceof ComponentPort) { |
| val cName = object?.containingComponent.qualifiedName |
| val kind = object?.kind |
| val name = object?.name |
| val s1 = ppName(cName, "<component>") |
| val s2 = if(kind === null || kind == InterfaceKind::_UNDEFINED_) "<kind>" else kind.literal |
| val s3 = ppName(name, "<port>") |
| return s1 + " " + s2 + " " + s3 |
| } else { |
| return defaultText |
| } |
| } |
| |
| /***************************************************************************** |
| * QualifiedPortItemProvider |
| *****************************************************************************/ |
| def static String getQualifiedPortItemProviderText(Object object, String defaultText) { |
| if (object instanceof QualifiedPort) { |
| val instName = object?.instance?.name |
| val portName = object?.port?.name |
| var String s2 = "" |
| var String s4 = "" |
| if (object?.instance === null) { |
| s4 = " (enclosing composite)" |
| } else { |
| s2 = if(instName.isNullOrEmpty) "??? / " else instName + " / " |
| } |
| val s3 = if(portName.isNullOrEmpty) "<port>" else portName |
| return getContainingFeatureName(object) + s2 + s3 + s4 |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getQualifiedPortItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(QualifiedPort)) { |
| case AmaltheaPackage::QUALIFIED_PORT__INSTANCE, |
| case AmaltheaPackage::QUALIFIED_PORT__PORT: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| |
| /***************************************************************************** |
| * MainInterfaceItemProvider |
| *****************************************************************************/ |
| def static ViewerNotification getMainInterfaceItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(MainInterface)) { |
| case AmaltheaPackage::MAIN_INTERFACE__NAME, |
| case AmaltheaPackage::MAIN_INTERFACE__NAMESPACE: |
| return new ViewerNotification(notification, notification.getNotifier(), true, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * SubInterfaceItemProvider |
| *****************************************************************************/ |
| def static ViewerNotification getSubInterfaceItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(SubInterface)) { |
| case AmaltheaPackage::SUB_INTERFACE__NAME: |
| return new ViewerNotification(notification, notification.getNotifier(), true, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * InterfaceChannelItemProvider |
| *****************************************************************************/ |
| def static String getInterfaceChannelItemProviderText(Object object, String defaultText) { |
| if (object instanceof InterfaceChannelImpl) { |
| val key = object?.getKey() |
| val value = object?.getValue() |
| val s1 = if(key === null || key.name.isNullOrEmpty) "<interface>" else "Interface " + key.name |
| val s2 = if(value === null || value.name.isNullOrEmpty) "<channel>" else "Channel " + value.name |
| return s1 + " -> " + s2 |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getInterfaceChannelItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(Map.Entry)) { |
| case AmaltheaPackage::INTERFACE_CHANNEL__KEY, |
| case AmaltheaPackage::INTERFACE_CHANNEL__VALUE: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| ///// |
| ///// _________________________ Config _________________________ |
| ///// |
| |
| /***************************************************************************** |
| * EventConfigItemProvider |
| *****************************************************************************/ |
| def static String getEventConfigItemProviderText(Object object, String defaultText, AdapterFactory rootAF) { |
| if (object instanceof EventConfig) { |
| val name = object?.name |
| val event = object?.event |
| val s1 = ppName(name) |
| var s2 = if(event === null) "<event>" else getLabelProviderText(event, rootAF) |
| |
| return "Config " + s1 + " -> trace " + s2 |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getEventConfigItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(EventConfig)) { |
| case AmaltheaPackage::EVENT_CONFIG__NAME: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| case AmaltheaPackage::EVENT_CONFIG__EVENT: |
| return new ViewerNotification(notification, notification.getNotifier(), true, true) |
| } |
| return null |
| } |
| |
| ///// |
| ///// _________________________ Constraints _________________________ |
| ///// |
| |
| private def static getLimitTypeText(LimitType limitType) { |
| switch limitType { |
| case LimitType::UPPER_LIMIT: " <= " |
| case LimitType::LOWER_LIMIT: " >= " |
| default: " ? " |
| } |
| } |
| |
| /***************************************************************************** |
| * ComponentScopeItemProvider |
| *****************************************************************************/ |
| def static String getComponentScopeItemProviderText(Object object, String defaultText) { |
| if (object instanceof ComponentScope) { |
| val compName = object?.component?.name |
| val s1 = if(compName.isNullOrEmpty) "<component>" else "Component " + compName |
| return "Scope: " + s1 |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static List<ViewerNotification> getComponentScopeItemProviderNotifications(Notification notification) { |
| val list = newArrayList |
| switch notification.getFeatureID(typeof(ComponentScope)) { |
| case AmaltheaPackage::COMPONENT_SCOPE__COMPONENT: { |
| list.add(new ViewerNotification(notification, notification.getNotifier(), false, true)) |
| addParentLabelNotification(list, notification) |
| } |
| } |
| return list |
| } |
| |
| /***************************************************************************** |
| * ProcessScopeItemProvider |
| *****************************************************************************/ |
| def static String getProcessScopeItemProviderText(Object object, String defaultText) { |
| if (object instanceof ProcessScope) { |
| val proc = object?.process |
| val s1 = if(proc?.name.isNullOrEmpty) "<process>" else proc.eClass.name + " " + proc.name |
| return "Scope: " + s1 |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static List<ViewerNotification> getProcessScopeItemProviderNotifications(Notification notification) { |
| val list = newArrayList |
| switch notification.getFeatureID(typeof(ProcessScope)) { |
| case AmaltheaPackage::PROCESS_SCOPE__PROCESS: { |
| list.add(new ViewerNotification(notification, notification.getNotifier(), false, true)) |
| addParentLabelNotification(list, notification) |
| } |
| } |
| return list |
| } |
| |
| /***************************************************************************** |
| * RunnableScopeItemProvider |
| *****************************************************************************/ |
| def static String getRunnableScopeItemProviderText(Object object, String defaultText) { |
| if (object instanceof RunnableScope) { |
| val runName = object?.runnable?.name |
| val s1 = if(runName.isNullOrEmpty) "<runnable>" else "Runnable " + runName |
| return "Scope: " + s1 |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static List<ViewerNotification> getRunnableScopeItemProviderNotifications(Notification notification) { |
| val list = newArrayList |
| switch notification.getFeatureID(typeof(RunnableScope)) { |
| case AmaltheaPackage::RUNNABLE_SCOPE__RUNNABLE: { |
| list.add(new ViewerNotification(notification, notification.getNotifier(), false, true)) |
| addParentLabelNotification(list, notification) |
| } |
| } |
| return list |
| } |
| |
| /***************************************************************************** |
| * ArchitectureRequirementItemProvider |
| *****************************************************************************/ |
| def static String getArchitectureRequirementItemProviderText(Object object, String defaultText) { |
| if (object instanceof ArchitectureRequirement) { |
| val reqName = object?.name |
| val compName = object?.component?.name |
| val s1 = ppName(reqName) |
| val s2 = if(compName.isNullOrEmpty) "<component>" else "Component " + compName |
| return "Req " + s1 + " -- " + s2 |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getArchitectureRequirementItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(ArchitectureRequirement)) { |
| case AmaltheaPackage::ARCHITECTURE_REQUIREMENT__NAME, |
| case AmaltheaPackage::ARCHITECTURE_REQUIREMENT__COMPONENT: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * CountRequirementLimitItemProvider |
| *****************************************************************************/ |
| def static String getCountRequirementLimitItemProviderText(Object object, String defaultText) { |
| if (object instanceof CountRequirementLimit) { |
| val metric = object?.metric |
| val limitType = object?.limitType |
| val limitValue = if(object === null) 0 else object.limitValue |
| val s1 = if(metric === null || metric == CountMetric::_UNDEFINED_) "<count metric>" else metric.literal + " count" |
| val s2 = getLimitTypeText(limitType) |
| val s3 = Double.toString(limitValue) |
| return s1 + s2 + s3 |
| } else { |
| return defaultText |
| } |
| } |
| |
| /***************************************************************************** |
| * CPUPercentageRequirementLimitItemProvider |
| *****************************************************************************/ |
| def static String getCPUPercentageRequirementLimitItemProviderText(Object object, String defaultText) { |
| if (object instanceof CPUPercentageRequirementLimit) { |
| val metric = object?.metric |
| val hwContext = object?.hardwareContext?.name |
| val limitType = object?.limitType |
| val limitValue = if(object === null) 0 else object.limitValue |
| val s1 = if(metric === null || metric == CPUPercentageMetric::_UNDEFINED_) "<CPU % metric>" else metric.literal |
| val s2 = if(hwContext.isNullOrEmpty) "" else " on " + hwContext |
| val s3 = getLimitTypeText(limitType) |
| val s4 = Double.toString(limitValue) + " %" |
| return s1 + s2 + s3 + s4 |
| } else { |
| return defaultText |
| } |
| } |
| |
| /***************************************************************************** |
| * FrequencyRequirementLimitItemProvider |
| *****************************************************************************/ |
| def static String getFrequencyRequirementLimitItemProviderText(Object object, String defaultText) { |
| if (object instanceof FrequencyRequirementLimit) { |
| val metric = object?.metric |
| val limitType = object?.limitType |
| val limitValue = object?.limitValue |
| val s1 = if(metric === null || metric == FrequencyMetric::_UNDEFINED_) "<frequency metric>" else metric.literal |
| val s2 = getLimitTypeText(limitType) |
| val s3 = getFrequencyText(limitValue) |
| return s1 + s2 + s3 |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getFrequencyRequirementLimitItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(FrequencyRequirementLimit)) { |
| case AmaltheaPackage::FREQUENCY_REQUIREMENT_LIMIT__METRIC: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| case AmaltheaPackage::FREQUENCY_REQUIREMENT_LIMIT__LIMIT_VALUE: |
| return new ViewerNotification(notification, notification.getNotifier(), true, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * PercentageRequirementLimitItemProvider |
| *****************************************************************************/ |
| def static String getPercentageRequirementLimitItemProviderText(Object object, String defaultText) { |
| if (object instanceof PercentageRequirementLimit) { |
| val metric = object?.metric |
| val limitType = object?.limitType |
| val limitValue = if(object === null) 0 else object.limitValue |
| val s1 = if(metric === null || metric == PercentageMetric::_UNDEFINED_) "<% metric>" else metric.literal |
| val s2 = getLimitTypeText(limitType) |
| val s3 = Double.toString(limitValue) + " %" |
| return s1 + s2 + s3 |
| } else { |
| return defaultText |
| } |
| } |
| |
| /***************************************************************************** |
| * TimeRequirementLimitItemProvider |
| *****************************************************************************/ |
| def static String getTimeRequirementLimitItemProviderText(Object object, String defaultText) { |
| if (object instanceof TimeRequirementLimit) { |
| val metric = object?.metric |
| val limitType = object?.limitType |
| val limitValue = object?.limitValue |
| val s1 = if(metric === null || metric == TimeMetric::_UNDEFINED_) "<time metric>" else metric.literal |
| val s2 = getLimitTypeText(limitType) |
| val s3 = getTimeText(limitValue) |
| return s1 + s2 + s3 |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getTimeRequirementLimitItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(TimeRequirementLimit)) { |
| case AmaltheaPackage::TIME_REQUIREMENT_LIMIT__METRIC: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| case AmaltheaPackage::TIME_REQUIREMENT_LIMIT__LIMIT_VALUE: |
| return new ViewerNotification(notification, notification.getNotifier(), true, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * ProcessRequirementItemProvider |
| *****************************************************************************/ |
| def static String getProcessRequirementItemProviderText(Object object, String defaultText) { |
| if (object instanceof ProcessRequirement) { |
| val reqName = object?.name |
| val proc = object?.process |
| val s1 = ppName(reqName) |
| val s2 = if(proc?.name.isNullOrEmpty) "<process>" else proc.eClass.name + " " + proc.name |
| return "Req " + s1 + " -- " + s2 |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getProcessRequirementItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(ProcessRequirement)) { |
| case AmaltheaPackage::PROCESS_REQUIREMENT__NAME, |
| case AmaltheaPackage::PROCESS_REQUIREMENT__PROCESS: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * RunnableRequirementItemProvider |
| *****************************************************************************/ |
| def static String getRunnableRequirementItemProviderText(Object object, String defaultText) { |
| if (object instanceof RunnableRequirement) { |
| val reqName = object?.name |
| val runName = object?.runnable?.name |
| val s1 = ppName(reqName) |
| val s2 = if(runName.isNullOrEmpty) "<runnable>" else "Runnable " + runName |
| return "Req " + s1 + " -- " + s2 |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getRunnableRequirementItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(RunnableRequirement)) { |
| case AmaltheaPackage::RUNNABLE_REQUIREMENT__NAME, |
| case AmaltheaPackage::RUNNABLE_REQUIREMENT__RUNNABLE: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * ProcessChainRequirementItemProvider |
| *****************************************************************************/ |
| def static String getProcessChainRequirementItemProviderText(Object object, String defaultText) { |
| if (object instanceof ProcessChainRequirement) { |
| val reqName = object?.name |
| val pcName = object?.processChain?.name |
| val s1 = ppName(reqName) |
| val s2 = if(pcName.isNullOrEmpty) "<process chain>" else "Process Chain " + pcName |
| return "Req " + s1 + " -- " + s2 |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getProcessChainRequirementItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(ProcessChainRequirement)) { |
| case AmaltheaPackage::PROCESS_CHAIN_REQUIREMENT__NAME, |
| case AmaltheaPackage::PROCESS_CHAIN_REQUIREMENT__PROCESS_CHAIN: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * DataAgeCycleItemProvider |
| *****************************************************************************/ |
| def static String getDataAgeCycleItemProviderText(Object object, String defaultText) { |
| if (object instanceof DataAgeCycle) { |
| return "Age cycles c: " + object.minimumCycle + " <= c <= " + object.maximumCycle |
| } else { |
| return defaultText |
| } |
| } |
| |
| /***************************************************************************** |
| * DataAgeTimeItemProvider |
| *****************************************************************************/ |
| def static String getDataAgeTimeItemProviderText(Object object, String defaultText) { |
| if (object instanceof DataAgeTime) { |
| val minTime = object?.minimumTime |
| val maxTime = object?.maximumTime |
| return "Age time t: " + getTimeText(minTime) + " <= t <= " + getTimeText(maxTime) |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getDataAgeTimeItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(DataAgeTime)) { |
| case AmaltheaPackage::DATA_AGE_TIME__MINIMUM_TIME, |
| case AmaltheaPackage::DATA_AGE_TIME__MAXIMUM_TIME: |
| return new ViewerNotification(notification, notification.getNotifier(), true, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * DataCoherencyGroupItemProvider |
| *****************************************************************************/ |
| def static String getDataCoherencyGroupItemProviderText(Object object, String defaultText) { |
| if (object instanceof DataCoherencyGroup) { |
| val name = object?.name |
| val direction = object?.direction |
| val scope = object?.scope |
| val s1 = ppName(name, "<group>") |
| val s2 = if(direction === null || |
| direction == CoherencyDirection::_UNDEFINED_) "<direction>" else direction.literal |
| val s3 = switch scope { |
| RunnableScope: if(scope.runnable?.name.isNullOrEmpty) "<runnable>" else "Runnable " + |
| scope.runnable.name |
| ProcessScope: if(scope.process?.name.isNullOrEmpty) "<process>" else scope.process.eClass.name + " " + |
| scope.process.name |
| ComponentScope: if(scope.component?.name.isNullOrEmpty) "<component>" else "Component " + |
| scope.component.name |
| default: "?" |
| } |
| return "CoherencyGroup " + s1 + " " + s2 + " (Scope: " + s3 + ")" |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getDataCoherencyGroupItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(DataCoherencyGroup)) { |
| case AmaltheaPackage::DATA_COHERENCY_GROUP__NAME, |
| case AmaltheaPackage::DATA_COHERENCY_GROUP__DIRECTION: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| case AmaltheaPackage::DATA_COHERENCY_GROUP__SCOPE: |
| return new ViewerNotification(notification, notification.getNotifier(), true, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * EventChainReferenceItemProvider |
| *****************************************************************************/ |
| def static String getEventChainReferenceItemProviderText(Object object, String defaultText) { |
| if (object instanceof EventChainReference) { |
| val chainName = object?.eventChain?.name |
| val s1 = getContainingFeatureName(object) |
| val s2 = if(chainName.isNullOrEmpty) "<chain ref>" else "(Chain Ref) " + chainName |
| return s1 + s2 |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getEventChainReferenceItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(EventChainReference)) { |
| case AmaltheaPackage::EVENT_CHAIN_REFERENCE__EVENT_CHAIN: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * EventChainContainerItemProvider |
| *****************************************************************************/ |
| def static String getEventChainContainerItemProviderText(Object object, String defaultText) { |
| if (object instanceof EventChainContainer) { |
| val chain = object?.eventChain |
| val s1 = getContainingFeatureName(object) |
| val s2 = if(chain === null) "<sub chain>" else if(chain.name. |
| isNullOrEmpty) "Sub Chain" else "(Sub Chain) " + chain.name |
| return s1 + s2 |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getEventChainContainerItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(SubEventChain)) { |
| case AmaltheaPackage::EVENT_CHAIN_CONTAINER__EVENT_CHAIN: |
| return new ViewerNotification(notification, notification.getNotifier(), true, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * TagGroupItemProvider |
| *****************************************************************************/ |
| def static String getTagGroupItemProviderText(Object object, String defaultText) { |
| if (object instanceof TagGroup) { |
| val tagName = object?.tag?.name |
| val s1 = if(tagName.isNullOrEmpty) "<tag>" else "\"" + tagName + "\"" |
| return "Items with tag " + s1 |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getTagGroupItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(TagGroup)) { |
| case AmaltheaPackage::TAG_GROUP__TAG: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| ///// |
| ///// _________________________ Events _________________________ |
| ///// |
| |
| /***************************************************************************** |
| * PhysicalSectionConstraintItemProvider |
| *****************************************************************************/ |
| def static String getPhysicalSectionConstraintItemProviderText(Object object, String defaultText) { |
| if (object instanceof PhysicalSectionConstraint) { |
| val section = object?.section |
| val memories = object?.memories |
| |
| val sectionString = if(section?.name.isNullOrEmpty) "<section>" else "Section : " + section.name |
| |
| val List<String> memoryNames = new ArrayList<String>() |
| |
| if (!memories.isNullOrEmpty) { |
| memories.forEach [ it | |
| val st = if(it?.name.isNullOrEmpty) "???" else it.name |
| memoryNames.add(st) |
| ] |
| } |
| |
| val memoriesString = if (memoryNames.isNullOrEmpty) { |
| "<memories>" |
| } else { |
| if (memoryNames.size > 10) { |
| " Memories : " + memoryNames.subList(0, 10).join(', ') + ", ..." |
| } else { |
| " Memories : " + memoryNames.join(', ') |
| } |
| } |
| |
| val s0 = if(object?.name.isNullOrEmpty) "<name>" else object.name |
| |
| return s0 + " : (" + sectionString + ")" + " --> (" + memoriesString + ")"; |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getPhysicalSectionConstraintItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(PhysicalSectionConstraint)) { |
| case AmaltheaPackage::PHYSICAL_SECTION_CONSTRAINT__NAME: |
| return (new ViewerNotification(notification, notification.getNotifier(), false, false)) |
| case AmaltheaPackage::PHYSICAL_SECTION_CONSTRAINT__SECTION: |
| return new ViewerNotification(notification, notification.getNotifier(), true, true) |
| case AmaltheaPackage::PHYSICAL_SECTION_CONSTRAINT__MEMORIES: |
| return new ViewerNotification(notification, notification.getNotifier(), true, true) |
| } |
| return null |
| } |
| |
| ///// |
| ///// _________________________ HW _________________________ |
| ///// |
| |
| /***************************************************************************** |
| * HwStructureItemProvider |
| *****************************************************************************/ |
| |
| def static String getHwStructureItemProviderImageName(Object object, String defaultName) { |
| if (object instanceof HwStructure) { |
| switch (object.structureType) { |
| case SYSTEM: |
| return "HwStructure_System" |
| case ECU: |
| return "HwStructure_ECU" |
| case MICROCONTROLLER: |
| return "HwStructure_Microcontroller" |
| default: |
| return "HwStructure" |
| } |
| } else { |
| return defaultName |
| } |
| } |
| |
| /***************************************************************************** |
| * HwFeatureCategoryItemProvider |
| *****************************************************************************/ |
| def static ViewerNotification getHwFeatureCategoryItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(HwFeatureCategory)) { |
| case AmaltheaPackage::HW_FEATURE_CATEGORY__NAME, |
| case AmaltheaPackage::HW_FEATURE_CATEGORY__FEATURES: |
| return new ViewerNotification(notification, notification.getNotifier(), true, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * HwFeatureItemProvider |
| *****************************************************************************/ |
| def static String getHwFeatureItemProviderText(Object object, String defaultText) { |
| if (object instanceof HwFeature) { |
| return object.toString |
| } else { |
| return defaultText |
| } |
| } |
| |
| /***************************************************************************** |
| * HwPortItemProvider |
| *****************************************************************************/ |
| def static String getHwPortItemProviderText(Object object, String defaultText) { |
| if (object instanceof HwPort) { |
| val name = object.name |
| val cName = (object.eContainer as INamed).name |
| val cType = if(object.eContainer instanceof HwStructure) "<structure>" else "<module>" |
| |
| val s1 = ppName(cName, cType) |
| val s2 = ppName(name, "<port>") |
| return s1 + " -- " + s2 |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getHwPortItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(HwPort)) { |
| case AmaltheaPackage::HW_PORT__NAME: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * HwAccessElementItemProvider |
| *****************************************************************************/ |
| def static String getHwAccessElementItemProviderText(Object object, String defaultText) { |
| if (object instanceof HwAccessElement) { |
| val s1 = ppName(object.name, "???") |
| val s2 = ppName(object.source?.name, "<source>") |
| val s3 = ppName(object.destination?.name, "<destination>") |
| return s1 + ": " + s2 + " --> " + s3 |
| } |
| } |
| |
| def static ViewerNotification getHwAccessElementItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(HwAccessElement)) { |
| case AmaltheaPackage::HW_ACCESS_ELEMENT__NAME, |
| case AmaltheaPackage::HW_ACCESS_ELEMENT__SOURCE, |
| case AmaltheaPackage::HW_ACCESS_ELEMENT__DESTINATION: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| case AmaltheaPackage::HW_ACCESS_ELEMENT__ACCESS_PATH, |
| case AmaltheaPackage::HW_ACCESS_ELEMENT__READ_LATENCY, |
| case AmaltheaPackage::HW_ACCESS_ELEMENT__WRITE_LATENCY, |
| case AmaltheaPackage::HW_ACCESS_ELEMENT__DATA_RATE: |
| return new ViewerNotification(notification, notification.getNotifier(), true, false) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * HwAccessPathItemProvider |
| *****************************************************************************/ |
| def static String getHwAccessPathItemProviderText(Object object, String defaultText) { |
| if (object instanceof HwAccessPath) { |
| return object.name |
| } |
| } |
| |
| /***************************************************************************** |
| * HwConnectionItemProvider |
| *****************************************************************************/ |
| def static String getHwConnectionItemProviderText(Object object, String defaultText) { |
| if (object instanceof HwConnection) { |
| val cName1 = (object.port1?.eContainer as INamed)?.name |
| val cName2 = (object.port2?.eContainer as INamed)?.name |
| |
| val s1 = ppName(object.name, "???") |
| val s2 = ppName(cName1, "<module1>") |
| val s3 = ppName(object.port1?.name, "<port1>") |
| val s4 = ppName(cName2, "<module2>") |
| val s5 = ppName(object.port2?.name, "<port2>") |
| return s1 + ": " + s2 + "_" + s3 + " --> " + s4 + "_" + s5 |
| } |
| } |
| |
| def static ViewerNotification getHwConnectionItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(HwConnection)) { |
| case AmaltheaPackage::HW_CONNECTION__NAME, |
| case AmaltheaPackage::HW_CONNECTION__PORT1, |
| case AmaltheaPackage::HW_CONNECTION__PORT2: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| case AmaltheaPackage.HW_CONNECTION__READ_LATENCY, |
| case AmaltheaPackage.HW_CONNECTION__WRITE_LATENCY, |
| case AmaltheaPackage.HW_CONNECTION__DATA_RATE: |
| return new ViewerNotification(notification, notification.getNotifier(), true, false) |
| } |
| return null |
| } |
| |
| ///// |
| ///// _________________________ Mapping _________________________ |
| ///// |
| |
| /***************************************************************************** |
| * MappingModelItemProvider |
| *****************************************************************************/ |
| def static String getMappingModelItemProviderText(Object object, String defaultText) { |
| return "Mapping" |
| } |
| |
| /***************************************************************************** |
| * SchedulerAllocationItemProvider |
| *****************************************************************************/ |
| def static String getSchedulerAllocationItemProviderText(Object object, String defaultText) { |
| if (object instanceof SchedulerAllocation) { |
| val schedName = object?.scheduler?.name |
| val cores = object?.responsibility |
| val s1 = if(schedName.isNullOrEmpty) "<scheduler>" else "Scheduler " + schedName |
| val s2 = cores.map[e|ppName(e?.name)].join(", ") |
| return "Allocation: " + s1 + " -- Processing Units ( " + s2 + " )"; |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getSchedulerAllocationItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(SchedulerAllocation)) { |
| case AmaltheaPackage::SCHEDULER_ALLOCATION__SCHEDULER, |
| case AmaltheaPackage::SCHEDULER_ALLOCATION__RESPONSIBILITY: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| case AmaltheaPackage::SCHEDULER_ALLOCATION__CUSTOM_PROPERTIES: |
| return new ViewerNotification(notification, notification.getNotifier(), true, false) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * ISRAllocationItemProvider |
| *****************************************************************************/ |
| def static String getISRAllocationItemProviderText(Object object, String defaultText) { |
| if (object instanceof ISRAllocation) { |
| val ctrlName = object?.controller?.name |
| val isrName = object?.isr?.name |
| val s1 = if(ctrlName.isNullOrEmpty) "<controller>" else "Controller " + ctrlName |
| val s2 = if(isrName.isNullOrEmpty) "<isr>" else "ISR " + isrName |
| return "Allocation: " + s1 + " -- " + s2; |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getISRAllocationItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(ISRAllocation)) { |
| case AmaltheaPackage::ISR_ALLOCATION__CONTROLLER, |
| case AmaltheaPackage::ISR_ALLOCATION__ISR: |
| // update the label but not the content tree |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * RunnableAllocationItemProvider |
| *****************************************************************************/ |
| def static String getRunnableAllocationItemProviderText(Object object, String defaultText) { |
| if (object instanceof RunnableAllocation) { |
| val schedName = object?.scheduler?.name |
| val entityName = object?.entity?.name |
| val s1 = if(schedName.isNullOrEmpty) "<scheduler>" else "Scheduler " + schedName |
| val s2 = if(entityName.isNullOrEmpty) "<runnable>" else "Runnable " + entityName |
| return "Allocation: " + s1 + " -- " + s2; |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getRunnableAllocationItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(RunnableAllocation)) { |
| case AmaltheaPackage::RUNNABLE_ALLOCATION__ENTITY, |
| case AmaltheaPackage::RUNNABLE_ALLOCATION__SCHEDULER: |
| // update the label but not the content tree |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * TaskAllocationItemProvider |
| *****************************************************************************/ |
| def static String getTaskAllocationItemProviderText(Object object, String defaultText) { |
| if (object instanceof TaskAllocation) { |
| val schedName = object?.scheduler?.name |
| val taskName = object?.task?.name |
| val s1 = if(schedName.isNullOrEmpty) "<scheduler>" else "Scheduler " + schedName |
| val s2 = if(taskName.isNullOrEmpty) "<task>" else "Task " + taskName |
| return "Allocation: " + s1 + " -- " + s2; |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getTaskAllocationItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(TaskAllocation)) { |
| case AmaltheaPackage::TASK_ALLOCATION__TASK, |
| case AmaltheaPackage::TASK_ALLOCATION__SCHEDULER: |
| // update the label |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| case AmaltheaPackage.TASK_ALLOCATION__SCHEDULING_PARAMETERS, |
| case AmaltheaPackage.TASK_ALLOCATION__PARAMETER_EXTENSIONS: |
| // update the content tree |
| return new ViewerNotification(notification, notification.getNotifier(), true, false) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * MemoryMappingItemProvider |
| *****************************************************************************/ |
| def static String getMemoryMappingItemProviderText(Object object, String defaultText) { |
| if (object instanceof MemoryMapping) { |
| val memName = object?.memory?.name |
| val elem = object?.abstractElement |
| val s1 = if(memName.isNullOrEmpty) "<memory>" else "Memory " + memName |
| val s2 = if(elem?.name.isNullOrEmpty) "<element>" else elem.eClass.name + " " + elem.name |
| return "Mapping: " + s1 + " -- " + s2; |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getMemoryMappingItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(MemoryMapping)) { |
| case AmaltheaPackage::MEMORY_MAPPING__MEMORY, |
| case AmaltheaPackage::MEMORY_MAPPING__ABSTRACT_ELEMENT: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * PhysicalSectionMappingItemProvider |
| *****************************************************************************/ |
| def static String getPhysicalSectionMappingItemProviderText(Object object, String defaultText) { |
| if (object instanceof PhysicalSectionMapping) { |
| val memory = object?.memory |
| val sections = object?.origin |
| |
| val memoryString = if(memory?.name.isNullOrEmpty) "<memory>" else "Memory : " + memory.name |
| |
| val List<String> sectionNames = new ArrayList<String>() |
| |
| if (!sections.isNullOrEmpty) { |
| sections.forEach [ it | |
| val st = if(it?.name.isNullOrEmpty) "???" else it.name |
| sectionNames.add(st) |
| ] |
| } |
| |
| val sectionsString = if (sectionNames.isNullOrEmpty) { |
| "<sections>" |
| } else { |
| if (sectionNames.size > 10) { |
| " Sections : " + sectionNames.subList(0, 10).join(', ') + ", ..." |
| } else { |
| " Sections : " + sectionNames.join(', ') |
| } |
| } |
| |
| val s0 = ppName(object?.name, "<name>") |
| |
| return s0 + " : (" + sectionsString + ")" + " --> (" + memoryString + ")"; |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getPhysicalSectionMappingItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(PhysicalSectionMapping)) { |
| case AmaltheaPackage::PHYSICAL_SECTION_MAPPING__MEMORY: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| case AmaltheaPackage::PHYSICAL_SECTION_MAPPING__ORIGIN: |
| return new ViewerNotification(notification, notification.getNotifier(), true, true) |
| case AmaltheaPackage::PHYSICAL_SECTION_MAPPING__NAME: |
| return new ViewerNotification(notification, notification.getNotifier(), true, false) |
| } |
| return null |
| } |
| |
| ///// |
| ///// _________________________ OS _________________________ |
| ///// |
| |
| /***************************************************************************** |
| * OsDataConsistencyItemProvider |
| *****************************************************************************/ |
| def static String getOsDataConsistencyItemProviderText(Object object, String defaultText) { |
| if (object instanceof OsDataConsistency) { |
| val mode = object.mode |
| |
| val s1 = "OS Data Consistency - " |
| val s2 = if(mode === null || mode == OsDataConsistencyMode::_UNDEFINED_) "?" else mode.literal |
| return s1 + s2 |
| } else { |
| return defaultText |
| } |
| } |
| |
| /***************************************************************************** |
| * DataStabilityItemProvider |
| *****************************************************************************/ |
| def static String getDataStabilityItemProviderText(Object object, String defaultText) { |
| if (object instanceof DataStability) { |
| return "OS Data Stability - enabled: " + object.enabled.toString |
| } else { |
| return defaultText |
| } |
| } |
| |
| /***************************************************************************** |
| * NonAtomicDataCoherencyItemProvider |
| *****************************************************************************/ |
| def static String getNonAtomicDataCoherencyItemProviderText(Object object, String defaultText) { |
| if (object instanceof NonAtomicDataCoherency) { |
| return "OS Data Coherency - enabled: " + object.enabled.toString |
| } else { |
| return defaultText |
| } |
| } |
| |
| /***************************************************************************** |
| * OsOverheadItemProvider |
| *****************************************************************************/ |
| def static String getOsOverheadItemProviderText(Object object, String defaultText) { |
| if (object instanceof OsOverhead) { |
| val name = object.name |
| val s1 = if(name.isNullOrEmpty) "OS Overhead" else name |
| return s1 |
| } else { |
| return defaultText |
| } |
| } |
| |
| /***************************************************************************** |
| * OsAPIOverheadItemProvider |
| *****************************************************************************/ |
| def static String getOsAPIOverheadItemProviderText(Object object, String defaultText) { |
| if (object instanceof OsAPIOverhead) { |
| return getContainingFeatureName(object, "API Overhead", "") |
| } else { |
| return defaultText |
| } |
| } |
| |
| /***************************************************************************** |
| * OsISROverheadItemProvider |
| *****************************************************************************/ |
| def static String getOsISROverheadItemProviderText(Object object, String defaultText) { |
| if (object instanceof OsISROverhead) { |
| return getContainingFeatureName(object, "ISR Overhead", "") |
| } else { |
| return defaultText |
| } |
| } |
| |
| /***************************************************************************** |
| * SchedulingParametersItemProvider |
| *****************************************************************************/ |
| def static String getSchedulingParametersItemProviderText(Object object, String defaultText) { |
| if (object instanceof SchedulingParameters) { |
| return "Parameters (Scheduling)"; |
| } else { |
| return defaultText |
| } |
| } |
| |
| ///// |
| ///// _________________________ PropertyConstraints _________________________ |
| ///// |
| |
| /***************************************************************************** |
| * ProcessPrototypeAllocationConstraintItemProvider |
| *****************************************************************************/ |
| def static String getProcessPrototypeAllocationConstraintItemProviderText(Object object, String defaultText) { |
| if (object instanceof ProcessPrototypeAllocationConstraint) { |
| val name = object?.processPrototype?.name |
| val s1 = if(name.isNullOrEmpty) "<process prototype>" else "Prototype " + name |
| return "Constraint allocation of " + s1 |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getProcessPrototypeAllocationConstraintItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(ProcessPrototypeAllocationConstraint)) { |
| case AmaltheaPackage::PROCESS_PROTOTYPE_ALLOCATION_CONSTRAINT__PROCESS_PROTOTYPE: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * ProcessAllocationConstraintItemProvider |
| *****************************************************************************/ |
| def static String getProcessAllocationConstraintItemProviderText(Object object, String defaultText) { |
| if (object instanceof ProcessAllocationConstraint) { |
| val proc = object?.process |
| val s1 = if(proc?.name.isNullOrEmpty) "<process>" else proc.eClass.name + " " + proc.name |
| return "Constraint allocation of " + s1 |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getProcessAllocationConstraintItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(ProcessAllocationConstraint)) { |
| case AmaltheaPackage::PROCESS_ALLOCATION_CONSTRAINT__PROCESS: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * RunnableAllocationConstraintItemProvider |
| *****************************************************************************/ |
| def static String getRunnableAllocationConstraintItemProviderText(Object object, String defaultText) { |
| if (object instanceof RunnableAllocationConstraint) { |
| val runName = object?.runnable?.name |
| val s1 = if(runName.isNullOrEmpty) "<runnable>" else "Runnable " + runName |
| return "Constraint allocation of " + s1 |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getRunnableAllocationConstraintItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(RunnableAllocationConstraint)) { |
| case AmaltheaPackage::RUNNABLE_ALLOCATION_CONSTRAINT__RUNNABLE: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * CoreClassificationItemProvider |
| *****************************************************************************/ |
| def static String getCoreClassificationItemProviderText(Object object, String defaultText) { |
| if (object instanceof CoreClassification) { |
| val con = object?.condition |
| val grp = object?.grouping |
| val cla = object?.classifiers |
| |
| val s1 = if(con === null || con == Condition::_UNDEFINED_) "<condition>" else con.literal |
| val s2 = if(grp === null || grp == GroupingType::_UNDEFINED_) "<grouping>" else ppCamelCase(grp.literal).toLowerCase |
| val s3 = if(cla.isNullOrEmpty) "<classifiers>" else cla.map[e|ppName(e?.name)].join(", ") |
| return s1 + " (" + s2 + "): " + s3; |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getCoreClassificationItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(CoreClassification)) { |
| case AmaltheaPackage::CORE_CLASSIFICATION__CONDITION, |
| case AmaltheaPackage::CORE_CLASSIFICATION__GROUPING, |
| case AmaltheaPackage::CORE_CLASSIFICATION__CLASSIFIERS: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * AbstractElementMappingConstraintItemProvider |
| *****************************************************************************/ |
| def static String getAbstractElementMappingConstraintItemProviderText(Object object, String defaultText) { |
| if (object instanceof AbstractElementMappingConstraint) { |
| val elem = object?.abstractElement |
| val s1 = if(elem?.name.isNullOrEmpty) "<element>" else elem.eClass.name + " " + elem.name |
| return "Constraint mapping of " + s1 |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getAbstractElementMappingConstraintItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(AbstractElementMappingConstraint)) { |
| case AmaltheaPackage::ABSTRACT_ELEMENT_MAPPING_CONSTRAINT__ABSTRACT_ELEMENT: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * MemoryClassificationItemProvider |
| *****************************************************************************/ |
| def static String getMemoryClassificationItemProviderText(Object object, String defaultText) { |
| if (object instanceof MemoryClassification) { |
| val con = object?.condition |
| val grp = object?.grouping |
| val cla = object?.classifiers |
| |
| val s1 = if(con === null || con == Condition::_UNDEFINED_) "<condition>" else con.literal |
| val s2 = if(grp === null || grp == GroupingType::_UNDEFINED_) "<grouping>" else ppCamelCase(grp.literal).toLowerCase |
| val s3 = if(cla.isNullOrEmpty) "<classifiers>" else cla.map[e|ppName(e?.name)].join(", ") |
| return s1 + " (" + s2 + "): " + s3; |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getMemoryClassificationItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(MemoryClassification)) { |
| case AmaltheaPackage::MEMORY_CLASSIFICATION__CONDITION, |
| case AmaltheaPackage::MEMORY_CLASSIFICATION__GROUPING, |
| case AmaltheaPackage::MEMORY_CLASSIFICATION__CLASSIFIERS: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| ///// |
| ///// _________________________ Stimuli _________________________ |
| ///// |
| |
| /***************************************************************************** |
| * ModeValueListItemProvider |
| *****************************************************************************/ |
| def static String getModeValueListItemProviderText(Object object, String defaultText) { |
| if (object instanceof ModeValueList) { |
| return getContainingFeatureName(object) + defaultText |
| } else { |
| return defaultText |
| } |
| } |
| |
| /***************************************************************************** |
| * ModeConditionDisjunctionItemProvider |
| *****************************************************************************/ |
| def static String getModeConditionDisjunctionItemProviderText(Object object, String defaultText) { |
| if (object instanceof ModeConditionDisjunction) { |
| return getContainingFeatureName(object) + "OR" |
| } else { |
| return defaultText |
| } |
| } |
| |
| /***************************************************************************** |
| * ModeConditionConjunctionItemProvider |
| *****************************************************************************/ |
| def static String getModeConditionConjunctionItemProviderText(Object object, String defaultText) { |
| if (object instanceof ModeConditionConjunction) { |
| return "AND" |
| } else { |
| return defaultText |
| } |
| } |
| |
| /***************************************************************************** |
| * ModeAssignmentItemProvider |
| *****************************************************************************/ |
| def static String getModeAssignmentItemProviderText(Object object, String defaultText) { |
| if (object instanceof ModeAssignment) { |
| val label = object.label |
| val value = object.value |
| |
| val s1 = if(label?.name.isNullOrEmpty) "<mode label>" else "Mode Label " + label.name |
| val s2 = if(value === null) "<value>" else value |
| val relation = " := " |
| return s1 + relation + s2 |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getModeAssignmentItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(ModeAssignment)) { |
| case AmaltheaPackage::MODE_VALUE__LABEL, |
| case AmaltheaPackage::MODE_VALUE__VALUE: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| |
| private def static getRelationOperatorText(RelationalOperator relation) { |
| switch relation { |
| case _UNDEFINED_: " <relation> " |
| case EQUAL: " == " |
| case NOT_EQUAL: " != " |
| case LESS_THAN: " < " |
| case GREATER_THAN: " > " |
| } |
| } |
| |
| /***************************************************************************** |
| * ModeValueConditionItemProvider |
| *****************************************************************************/ |
| def static String getModeValueConditionItemProviderText(Object object, String defaultText) { |
| if (object instanceof ModeValueCondition) { |
| val label = object.label |
| val value = object.value |
| |
| val s1 = if(label?.name.isNullOrEmpty) "<mode label>" else "Mode Label " + label.name |
| val s2 = if(value === null) "<value>" else value |
| val relation = getRelationOperatorText(object.relation) |
| return s1 + relation + s2 |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getModeValueConditionItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(ModeValueCondition)) { |
| case AmaltheaPackage::MODE_VALUE_CONDITION__LABEL, |
| case AmaltheaPackage::MODE_VALUE_CONDITION__VALUE, |
| case AmaltheaPackage::MODE_VALUE_CONDITION__RELATION: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * ModeLabelConditionItemProvider |
| *****************************************************************************/ |
| def static String getModeLabelConditionItemProviderText(Object object, String defaultText) { |
| if (object instanceof ModeLabelCondition) { |
| val label1 = object.label1 |
| val label2 = object.label2 |
| |
| val s1 = if(label1?.name.isNullOrEmpty) "<mode label>" else "Mode Label " + label1.name |
| val s2 = if(label2?.name.isNullOrEmpty) "<mode label>" else "Mode Label " + label2.name |
| val relation = getRelationOperatorText(object.relation) |
| return s1 + relation + s2 |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getModeLabelConditionItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(ModeLabelCondition)) { |
| case AmaltheaPackage::MODE_LABEL_CONDITION__LABEL1, |
| case AmaltheaPackage::MODE_LABEL_CONDITION__LABEL2, |
| case AmaltheaPackage::MODE_LABEL_CONDITION__RELATION: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * ArrivalCurveEntryItemProvider |
| *****************************************************************************/ |
| def static String getArrivalCurveEntryItemProviderText(Object object, String defaultText) { |
| if (object instanceof ArrivalCurveEntry) { |
| val num = if(object === null) 0 else object.numberOfOccurrences |
| val s1 = getTimeText(object?.lowerTimeBorder) |
| val s2 = getTimeText(object?.upperTimeBorder) |
| return "#occurrences: " + num + " -- interval: " + s1 + ", " + s2 |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getArrivalCurveEntryItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(ArrivalCurveEntry)) { |
| case AmaltheaPackage::ARRIVAL_CURVE_ENTRY__NUMBER_OF_OCCURRENCES: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| case AmaltheaPackage::ARRIVAL_CURVE_ENTRY__LOWER_TIME_BORDER, |
| case AmaltheaPackage::ARRIVAL_CURVE_ENTRY__UPPER_TIME_BORDER: |
| return new ViewerNotification(notification, notification.getNotifier(), true, true) |
| } |
| return null |
| } |
| |
| ///// |
| ///// _________________________ SW _________________________ |
| ///// |
| |
| // private def static getRunnableItemText(RunnableItem item) { |
| // switch item { |
| // LabelAccess: getLabelAccessItemProviderText(item, null) |
| // RunnableCall: getRunnableCallItemProviderText(item, null) |
| // ExecutionNeed: "Execution Need" |
| // Ticks: "Ticks" |
| // Group: getGroupItemProviderText(item, null) |
| // ModeSwitch: getRunnableModeSwitchItemProviderText(item, null) |
| // ProbabilitySwitch: "Probability Switch" |
| // ModeLabelAccess: getModeLabelAccessItemProviderText(item, null) |
| // SemaphoreAccess: getSemaphoreAccessItemProviderText(item, null) |
| // SenderReceiverRead: getSenderReceiverReadItemProviderText(item, null) |
| // SenderReceiverWrite: getSenderReceiverWriteItemProviderText(item, null) |
| // AsynchronousServerCall: getAsynchronousServerCallItemProviderText(item, null) |
| // SynchronousServerCall: getSynchronousServerCallItemProviderText(item, null) |
| // } |
| // } |
| |
| /***************************************************************************** |
| * AccessPrecedenceSpecItemProvider |
| *****************************************************************************/ |
| def static String getAccessPrecedenceSpecItemProviderText(Object object, String defaultText) { |
| if (object instanceof AccessPrecedenceSpec) { |
| val originName = object?.origin?.name |
| val targetName = object?.target?.name |
| val labelName = object?.label?.name |
| val accessType = object?.orderType |
| val s1 = ppName(originName, "<runnable>") |
| val s2 = ppName(targetName, "<runnable>") |
| val s3 = ppName(labelName, "<label>") |
| val s4 = if(accessType === null || accessType == AccessPrecedenceType::_UNDEFINED_) "<access>" else accessType.literal |
| return "Spec: " + s1 + " --> " + s2 + " (" + s3 + " : " + s4 + ")" |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getAccessPrecedenceSpecItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(AccessPrecedenceSpec)) { |
| case AmaltheaPackage::ACCESS_PRECEDENCE_SPEC__ORDER_TYPE, |
| case AmaltheaPackage::ACCESS_PRECEDENCE_SPEC__ORIGIN, |
| case AmaltheaPackage::ACCESS_PRECEDENCE_SPEC__TARGET, |
| case AmaltheaPackage::ACCESS_PRECEDENCE_SPEC__LABEL: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * OrderPrecedenceSpecItemProvider |
| *****************************************************************************/ |
| def static String getOrderPrecedenceSpecItemProviderText(Object object, String defaultText) { |
| if (object instanceof OrderPrecedenceSpec) { |
| val originName = object?.origin?.name |
| val targetName = object?.target?.name |
| val order = object?.orderType |
| val s1 = ppName(originName, "<runnable>") |
| val s2 = ppName(targetName, "<runnable>") |
| val s3 = if(order === null || order == OrderType::_UNDEFINED_) "<order>" else order.literal |
| return "Spec: " + s1 + " --> " + s2 + " (" + s3 + ")" |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getOrderPrecedenceSpecItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(OrderPrecedenceSpec)) { |
| case AmaltheaPackage::ORDER_PRECEDENCE_SPEC__ORDER_TYPE, |
| case AmaltheaPackage::ORDER_PRECEDENCE_SPEC__ORIGIN, |
| case AmaltheaPackage::ORDER_PRECEDENCE_SPEC__TARGET: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * AsynchronousServerCallItemProvider |
| *****************************************************************************/ |
| def static String getAsynchronousServerCallItemProviderText(Object object, String defaultText) { |
| if (object instanceof AsynchronousServerCall) { |
| val serverRun = object?.serverRunnable?.qualifiedName |
| val resultRun = object?.resultRunnable?.qualifiedName |
| val s1 = ppName(serverRun, "<runnable>") |
| val s2 = ppName(resultRun, "<runnable>") |
| return "call server: " + s1 + " (async - result: " + s2 + ")" |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getAsynchronousServerCallItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(AsynchronousServerCall)) { |
| case AmaltheaPackage::ASYNCHRONOUS_SERVER_CALL__SERVER_RUNNABLE, |
| case AmaltheaPackage::ASYNCHRONOUS_SERVER_CALL__RESULT_RUNNABLE: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * SynchronousServerCallItemProvider |
| *****************************************************************************/ |
| def static String getSynchronousServerCallItemProviderText(Object object, String defaultText) { |
| if (object instanceof SynchronousServerCall) { |
| val serverRun = object?.serverRunnable?.qualifiedName |
| val waiting = object?.waitingBehaviour |
| val s1 = ppName(serverRun, "<runnable>") |
| val s2 = if(waiting === null || waiting == WaitingBehaviour::_UNDEFINED_) "undefined" else waiting.literal |
| return "call server: " + s1 + " (sync - " + s2 + " waiting)" |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getSynchronousServerCallItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(SynchronousServerCall)) { |
| case AmaltheaPackage::SYNCHRONOUS_SERVER_CALL__SERVER_RUNNABLE, |
| case AmaltheaPackage::SYNCHRONOUS_SERVER_CALL__WAITING_BEHAVIOUR: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * GetResultServerCallItemProvider |
| *****************************************************************************/ |
| def static String getGetResultServerCallItemProviderText(Object object, String defaultText) { |
| if (object instanceof GetResultServerCall) { |
| val serverRun = object?.serverRunnable?.qualifiedName |
| val blocking = object?.blockingType |
| val s1 = ppName(serverRun, "<runnable>") |
| val s2 = if(blocking === null || blocking == BlockingType::_UNDEFINED_) "undefined" else blocking.literal.replace("_", " ") |
| return "call server: " + s1 + " (get result - " + s2 + ")" |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getGetResultServerCallItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(GetResultServerCall)) { |
| case AmaltheaPackage::GET_RESULT_SERVER_CALL__SERVER_RUNNABLE, |
| case AmaltheaPackage::GET_RESULT_SERVER_CALL__BLOCKING_TYPE: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * ChainedProcessPrototypeItemProvider |
| *****************************************************************************/ |
| def static String getChainedProcessPrototypeItemProviderText(Object object, String defaultText) { |
| if (object instanceof ChainedProcessPrototype) { |
| val proto = object?.prototype?.name |
| val apply = if(object === null) 0 else object.apply |
| val offset = if(object === null) 0 else object.offset |
| val s1 = ppName(proto, "<process prototype>") |
| return "Chained Prototype " + s1 + " ( apply: " + apply + " offset: " + offset + " )" |
| } else { |
| return defaultText |
| } |
| } |
| |
| def static ViewerNotification getChainedProcessPrototypeItemProviderNotification(Notification notification) { |
| switch notification.getFeatureID(typeof(ChainedProcessPrototype)) { |
| case AmaltheaPackage::CHAINED_PROCESS_PROTOTYPE__PROTOTYPE, |
| case AmaltheaPackage::CHAINED_PROCESS_PROTOTYPE__APPLY, |
| case AmaltheaPackage::CHAINED_PROCESS_PROTOTYPE__OFFSET: |
| return new ViewerNotification(notification, notification.getNotifier(), false, true) |
| } |
| return null |
| } |
| |
| /***************************************************************************** |
| * GroupItemProvider |
| *****************************************************************************/ |
| def static String getGroupItemProviderText(Object object, String defaultText) { |
| if (object instanceof Group) { |
| val name = if(object.name.isNullOrEmpty) null else object.name |
| val ordered = if(object === null) false else object.isOrdered |
| val result = if(ordered) "(Sequence)" else "(Set)" |
| return if(name === null) result else result + " " + name |
| } |
| } |
| |
| def static String getGroupItemProviderImageName(Object object, String defaultName) { |
| if (object instanceof Group) { |
| val ordered = if(object === null) false else object.isOrdered |
| return "Group_" + if(ordered) "ordered" else "unordered" |
| } else { |
| return defaultName |
| } |
| } |
| |
| /***************************************************************************** |
| * InterProcessTriggerItemProvider |
| *****************************************************************************/ |
| def static String getInterProcessTriggerItemProviderText(Object object, String defaultText) { |
| if (object instanceof InterProcessTrigger) { |
| val stimulusName = object?.getStimulus?.name |
|