| /******************************************************************************* |
| * Copyright (c) 2019 École Polytechnique de Montréal |
| * |
| * All rights reserved. This program and the accompanying materials are |
| * made available under the terms of the Eclipse Public License 2.0 which |
| * accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| *******************************************************************************/ |
| |
| package org.eclipse.tracecompass.internal.tmf.analysis.xml.core.fsm.compile; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.stream.Collectors; |
| |
| import org.eclipse.jdt.annotation.NonNull; |
| import org.eclipse.jdt.annotation.Nullable; |
| import org.eclipse.tracecompass.internal.tmf.analysis.xml.core.Activator; |
| import org.eclipse.tracecompass.internal.tmf.analysis.xml.core.fsm.model.DataDrivenFsm; |
| import org.eclipse.tracecompass.internal.tmf.analysis.xml.core.fsm.model.DataDrivenFsmSimpleState; |
| import org.eclipse.tracecompass.internal.tmf.analysis.xml.core.fsm.model.DataDrivenFsmState; |
| import org.eclipse.tracecompass.internal.tmf.analysis.xml.core.fsm.model.DataDrivenFsmStateTransition; |
| import org.eclipse.tracecompass.tmf.analysis.xml.core.module.TmfXmlStrings; |
| import org.eclipse.tracecompass.tmf.analysis.xml.core.module.TmfXmlUtils; |
| import org.w3c.dom.Element; |
| |
| /** |
| * A compilation unit for XML finite state machine |
| * |
| * @author Geneviève Bastien |
| * @author Jean-Christian Kouamé |
| */ |
| public abstract class TmfXmlFsmStateCu implements IDataDrivenCompilationUnit { |
| |
| /** |
| * Represents an FSM |
| */ |
| public static class TmfXmlFsmCu extends TmfXmlFsmStateCu { |
| |
| private final TmfXmlFsmStateCu fInitialState; |
| private final Collection<TmfXmlFsmSimpleStateCu> fStates; |
| private final TmfXmlConditionCu fPreCondition; |
| private final boolean fConsuming; |
| private final boolean fMultipleInstances; |
| |
| /** |
| * Constructor |
| * |
| * @param id |
| * The ID of this FSM |
| * @param initialStateCu |
| * The initial state compilation unit |
| * @param states |
| * The list of states |
| * @param consuming |
| * Whether this fsm is consuming (ie, once a transition is |
| * taken in one scenario, it won't be taken on others) |
| * @param instanceMultipleEnabled |
| * Whether multiple scenarios of this FSM can be run in |
| * parallel |
| * @param preCondition |
| * The preconditions for this FSM |
| */ |
| private TmfXmlFsmCu(String id, TmfXmlFsmStateCu initialStateCu, Collection<TmfXmlFsmSimpleStateCu> states, boolean consuming, boolean instanceMultipleEnabled, TmfXmlConditionCu preCondition) { |
| super(id); |
| fInitialState = initialStateCu; |
| fStates = states; |
| fPreCondition = preCondition; |
| fConsuming = consuming; |
| fMultipleInstances = instanceMultipleEnabled; |
| } |
| |
| @Override |
| public DataDrivenFsm generate() { |
| Map<String, DataDrivenFsmSimpleState> states = fStates.stream() |
| .map(TmfXmlFsmSimpleStateCu::generate) |
| .collect(Collectors.toMap(DataDrivenFsmState::getId, state -> state)); |
| |
| return new DataDrivenFsm(getId(), fInitialState.generate(), states, fPreCondition.generate(), fConsuming, fMultipleInstances); |
| } |
| |
| } |
| |
| /** |
| * Represent a final state, without transitions |
| */ |
| private static class TmfXmlFsmFinalStateCu extends TmfXmlFsmSimpleStateCu { |
| |
| public TmfXmlFsmFinalStateCu(String id) { |
| super(id, Collections.emptyList(), Collections.emptyList()); |
| } |
| |
| @Override |
| public DataDrivenFsmSimpleState generate() { |
| return DataDrivenFsmSimpleState.createFinalState(getId()); |
| } |
| |
| } |
| |
| /** |
| * Package-private class so other compilation units can see it |
| */ |
| static class TmfXmlFsmSimpleStateCu extends TmfXmlFsmStateCu { |
| |
| private final List<TmfXmlFsmStateTransitionCu> fTransitions = new ArrayList<>(); |
| private final TmfXmlActionCu fOnEntryActions; |
| private final TmfXmlActionCu fOnExitActions; |
| |
| private TmfXmlFsmSimpleStateCu(String id, List<TmfXmlActionCu> onEntryActions, List<TmfXmlActionCu> onExitActions) { |
| super(id); |
| fOnEntryActions = TmfXmlActionCu.createActionList(onEntryActions); |
| fOnExitActions = TmfXmlActionCu.createActionList(onExitActions); |
| } |
| |
| private void addTransitions(List<TmfXmlFsmStateTransitionCu> transitions) { |
| fTransitions.addAll(transitions); |
| } |
| |
| @Override |
| public DataDrivenFsmSimpleState generate() { |
| List<DataDrivenFsmStateTransition> transitions = fTransitions.stream() |
| .map(TmfXmlFsmStateTransitionCu::generate) |
| .collect(Collectors.toList()); |
| return new DataDrivenFsmSimpleState(getId(), transitions, fOnEntryActions.generate(), fOnExitActions.generate()); |
| } |
| |
| } |
| |
| private final String fId; |
| |
| private TmfXmlFsmStateCu(String id) { |
| fId = id; |
| } |
| |
| @Override |
| public abstract DataDrivenFsmState generate(); |
| |
| /** |
| * Get the ID of this FSM state |
| * |
| * @return The ID of the FSM state |
| */ |
| protected String getId() { |
| return fId; |
| } |
| |
| /** |
| * Compile a finite state machine from an XML element |
| * |
| * FIXME: Return the FSM directly when legacy code is gone |
| * |
| * @param analysisData |
| * The analysis data already compiled |
| * @param element |
| * the XML element corresponding to the fsm |
| * @return The FSM |
| */ |
| public static @Nullable TmfXmlFsmCu compileFsm(AnalysisCompilationData analysisData, Element element) { |
| String id = element.getAttribute(TmfXmlStrings.ID); |
| if (id.isEmpty()) { |
| // TODO: Validation message here |
| Activator.logError("FSM: The FSM should have a non-empty 'id' parameter"); //$NON-NLS-1$ |
| return null; |
| } |
| String consumingStr = element.getAttribute(TmfXmlStrings.CONSUMING); |
| String multipleInstancesStr = element.getAttribute(TmfXmlStrings.MULTIPLE); |
| boolean consuming = consumingStr.isEmpty() ? true : Boolean.parseBoolean(consumingStr); |
| boolean instanceMultipleEnabled = multipleInstancesStr.isEmpty() ? true : Boolean.parseBoolean(multipleInstancesStr); |
| |
| Map<String, TmfXmlFsmSimpleStateCu> states = new HashMap<>(); |
| // Create the FSM states, without transitions yet |
| // FSMs can be cyclic, so we need all states to be able to create the |
| // transitions |
| List<Element> stateElements = TmfXmlUtils.getChildElements(element, TmfXmlStrings.STATE); |
| TmfXmlFsmStateCu firstState = null; |
| for (Element stateElement : stateElements) { |
| TmfXmlFsmStateCu state = compileSimpleState(analysisData, stateElement, states, false); |
| if (state == null) { |
| return null; |
| } |
| // Save the first state in case there is no initial state |
| if (firstState == null) { |
| firstState = state; |
| } |
| } |
| |
| // Get the final state |
| List<Element> finalElements = TmfXmlUtils.getChildElements(element, TmfXmlStrings.FINAL); |
| if (!finalElements.isEmpty()) { |
| if (finalElements.size() > 1) { |
| // TODO: Validation message here |
| Activator.logWarning("Fsm " + id + ": there should be only one final state"); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| TmfXmlFsmSimpleStateCu state = compileSimpleState(analysisData, finalElements.get(0), states, true); |
| if (state == null) { |
| return null; |
| } |
| } |
| |
| // Compile the initial state |
| String initialStr = element.getAttribute(TmfXmlStrings.INITIAL); |
| List<Element> nodesInitialElement = TmfXmlUtils.getChildElements(element, TmfXmlStrings.INITIAL); |
| List<Element> nodesInitialStateElement = TmfXmlUtils.getChildElements(element, TmfXmlStrings.INITIAL_STATE); |
| TmfXmlFsmStateCu initialStateCu = null; |
| if (!nodesInitialStateElement.isEmpty()) { |
| if (!initialStr.isEmpty() || !nodesInitialElement.isEmpty()) { |
| // TODO: Validation message here |
| Activator.logWarning("Fsm " + id + ": the 'initial' attribute was set or an <initial> element was defined. Only one of the 3 should be used. The " + TmfXmlStrings.INITIAL_STATE + " element will have precedence"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| } |
| initialStateCu = compileInitialState(analysisData, nodesInitialStateElement.get(0), states); |
| if (initialStateCu == null) { |
| return null; |
| } |
| } else if (initialStr.isEmpty() && nodesInitialElement.isEmpty()) { |
| // Take the first state as initial state |
| if (firstState == null) { |
| // TODO: Validation message here |
| Activator.logError("FSM " + id + ": No state was defined."); //$NON-NLS-1$ //$NON-NLS-2$ |
| return null; |
| } |
| initialStateCu = firstState; |
| } else { |
| if (!initialStr.isEmpty() && !nodesInitialElement.isEmpty()) { |
| // TODO: Validation message here |
| Activator.logWarning("Fsm " + id + ": Both 'initial' attribute and <initial> element were declared. Only the 'initial' attribute will be used"); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| if (!initialStr.isEmpty()) { |
| // Take the initial attribute as initial state, but make sure |
| // the state exists |
| initialStateCu = states.get(initialStr); |
| if (initialStateCu == null) { |
| // TODO: Validation message here |
| Activator.logError("FSM " + id + ": Undefined initial state " + initialStr); //$NON-NLS-1$ //$NON-NLS-2$ |
| return null; |
| } |
| } else { |
| // The initial element is the equivalent of the initial |
| // attribute except the starting state is the name of the target |
| List<Element> transitionElements = TmfXmlUtils.getChildElements(nodesInitialElement.get(0), TmfXmlStrings.TRANSITION); |
| if (transitionElements.isEmpty()) { |
| // TODO: Validation message here |
| Activator.logError("FSM " + id + ": No transition defined for 'initial' element"); //$NON-NLS-1$ //$NON-NLS-2$ |
| return null; |
| } else if (transitionElements.size() > 1) { |
| // TODO: Validation message here |
| Activator.logWarning("FSM " + id + ": Too many transitions defined for 'initial' element. Only 1 needed"); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| initialStateCu = TmfXmlFsmStateTransitionCu.compileInitialTransition(analysisData, transitionElements.get(0), states); |
| if (initialStateCu == null) { |
| return null; |
| } |
| } |
| } |
| |
| // For each state, compile the transitions |
| for (Element stateElement : stateElements) { |
| TmfXmlFsmSimpleStateCu simpleState = getSimpleState(stateElement, states); |
| List<TmfXmlFsmStateTransitionCu> transitions = compileTransitionElements(analysisData, stateElement, states); |
| if (transitions == null) { |
| return null; |
| } |
| if (transitions.isEmpty()) { |
| // TODO: Validation message here |
| Activator.logWarning("Fsm " + id + ": a state was defined without transition. You may get stuck there"); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| simpleState.addTransitions(transitions); |
| } |
| |
| // Compile the preconditions |
| List<Element> preCondElements = TmfXmlUtils.getChildElements(element, TmfXmlStrings.PRECONDITION); |
| List<TmfXmlConditionCu> preConditions = new ArrayList<>(); |
| for (Element preCondElement : preCondElements) { |
| TmfXmlConditionCu preCond = TmfXmlFsmStateTransitionCu.compileAsCondition(analysisData, preCondElement); |
| if (preCond == null) { |
| return null; |
| } |
| preConditions.add(preCond); |
| } |
| TmfXmlConditionCu preCondition = TmfXmlConditionCu.createOrCondition(preConditions); |
| |
| TmfXmlFsmCu fsm = new TmfXmlFsmCu(id, initialStateCu, states.values(), consuming, instanceMultipleEnabled, preCondition); |
| analysisData.addFsm(id, fsm); |
| return fsm; |
| } |
| |
| private static @Nullable List<TmfXmlFsmStateTransitionCu> compileTransitionElements(AnalysisCompilationData analysisData, Element element, Map<String, TmfXmlFsmSimpleStateCu> states) { |
| List<Element> childElements = TmfXmlUtils.getChildElements(element, TmfXmlStrings.TRANSITION); |
| List<TmfXmlFsmStateTransitionCu> transitions = new ArrayList<>(); |
| for (Element childElement : childElements) { |
| TmfXmlFsmStateTransitionCu transition = TmfXmlFsmStateTransitionCu.compile(analysisData, childElement, states); |
| if (transition == null) { |
| return null; |
| } |
| transitions.add(transition); |
| } |
| return transitions; |
| } |
| |
| private static @Nullable TmfXmlFsmSimpleStateCu compileInitialState(AnalysisCompilationData analysisData, Element element, Map<String, TmfXmlFsmSimpleStateCu> states) { |
| List<TmfXmlFsmStateTransitionCu> transitions = compileTransitionElements(analysisData, element, states); |
| if (transitions == null) { |
| return null; |
| } |
| TmfXmlFsmSimpleStateCu initialState = new TmfXmlFsmSimpleStateCu(TmfXmlStrings.INITIAL_STATE, Collections.emptyList(), Collections.emptyList()); |
| initialState.addTransitions(transitions); |
| return initialState; |
| } |
| |
| private static @Nullable TmfXmlFsmSimpleStateCu compileSimpleState(AnalysisCompilationData analysisData, Element element, Map<String, TmfXmlFsmSimpleStateCu> states, boolean isFinalState) { |
| String stateId = element.getAttribute(TmfXmlStrings.ID); |
| if (stateId.isEmpty()) { |
| // TODO: Validation message here |
| Activator.logError("FSM State: The state should have a non-empty 'id' parameter"); //$NON-NLS-1$ |
| return null; |
| } |
| TmfXmlFsmStateCu currentStateCu = states.get(stateId); |
| if (currentStateCu != null) { |
| // TODO: Validation message here |
| Activator.logError("FSM State: Redefinition of state " + stateId); //$NON-NLS-1$ |
| return null; |
| } |
| |
| // Get the onEntry and onExit actions |
| List<Element> elements = TmfXmlUtils.getChildElements(element, TmfXmlStrings.ONENTRY); |
| List<TmfXmlActionCu> onEntryActions = Collections.emptyList(); |
| if (!elements.isEmpty()) { |
| onEntryActions = getActionList(analysisData, elements.get(0)); |
| if (onEntryActions == null) { |
| return null; |
| } |
| } |
| elements = TmfXmlUtils.getChildElements(element, TmfXmlStrings.ONEXIT); |
| List<TmfXmlActionCu> onExitActions = Collections.emptyList(); |
| if (!elements.isEmpty()) { |
| onExitActions = getActionList(analysisData, elements.get(0)); |
| if (onExitActions == null) { |
| return null; |
| } |
| } |
| |
| TmfXmlFsmSimpleStateCu stateCu; |
| if (isFinalState) { |
| if (!onExitActions.isEmpty() || !onEntryActions.isEmpty()) { |
| // TODO: Validation message here |
| Activator.logWarning("FSM State: Final state should not have any onEntry and onExit actions"); //$NON-NLS-1$ |
| } |
| stateCu = new TmfXmlFsmFinalStateCu(stateId); |
| } else { |
| stateCu = new TmfXmlFsmSimpleStateCu(stateId, onEntryActions, onExitActions); |
| } |
| states.put(stateId, stateCu); |
| return stateCu; |
| } |
| |
| private static @Nullable List<TmfXmlActionCu> getActionList(AnalysisCompilationData analysisData, Element element) { |
| List<TmfXmlActionCu> actions = new ArrayList<>(); |
| String onEntryActionStr = element.getAttribute(TmfXmlStrings.ACTION); |
| if (onEntryActionStr.isEmpty()) { |
| return actions; |
| } |
| @NonNull String[] actionIds = onEntryActionStr.split(TmfXmlStrings.AND_SEPARATOR); |
| for (String actionId : actionIds) { |
| TmfXmlActionCu action = analysisData.getAction(actionId); |
| if (action == null) { |
| // TODO: Validation message here |
| Activator.logError("FSM State: Undefined action " + actionId); //$NON-NLS-1$ |
| return null; |
| } |
| actions.add(action); |
| } |
| return actions; |
| } |
| |
| private static TmfXmlFsmSimpleStateCu getSimpleState(Element stateElement, Map<String, TmfXmlFsmSimpleStateCu> states) { |
| String stateId = stateElement.getAttribute(TmfXmlStrings.ID); |
| TmfXmlFsmStateCu state = states.get(stateId); |
| if (!(state instanceof TmfXmlFsmSimpleStateCu)) { |
| throw new NullPointerException("The requested state is not of the right type: " + stateId); //$NON-NLS-1$ |
| } |
| return (TmfXmlFsmSimpleStateCu) state; |
| } |
| |
| } |
