| /******************************************************************************* |
| * 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.model; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Objects; |
| |
| import org.eclipse.jdt.annotation.Nullable; |
| import org.eclipse.tracecompass.internal.tmf.analysis.xml.core.fsm.model.runtime.DataDrivenRuntimeData; |
| import org.eclipse.tracecompass.internal.tmf.analysis.xml.core.fsm.model.runtime.DataDrivenRuntimeFsm; |
| import org.eclipse.tracecompass.internal.tmf.analysis.xml.core.fsm.model.runtime.DataDrivenScenario; |
| import org.eclipse.tracecompass.internal.tmf.analysis.xml.core.fsm.model.runtime.DataDrivenScenarioInfo; |
| import org.eclipse.tracecompass.internal.tmf.analysis.xml.core.fsm.module.IAnalysisDataContainer; |
| import org.eclipse.tracecompass.tmf.core.event.ITmfEvent; |
| |
| /** |
| * A class representing a data driven finite state machine |
| * |
| * @author Geneviève Bastien |
| * @author Jean-Christian Kouamé |
| */ |
| public class DataDrivenFsm extends DataDrivenFsmState { |
| |
| private final DataDrivenFsmState fInitial; |
| private final Map<String, DataDrivenFsmSimpleState> fStates; |
| private final DataDrivenCondition fPrecondition; |
| private final boolean fConsuming; |
| private final boolean fMultipleInstances; |
| |
| /** |
| * Constructor |
| * |
| * @param id |
| * The ID of this FSM |
| * @param initial |
| * The initial state |
| * @param states |
| * The map of states for this state machine |
| * @param preCondition |
| * The precondition that should be matched for this state machine |
| * to be considered |
| * @param consuming |
| * Whether the state machine is consuming, ie if a transition is |
| * taken from any one scenario, then the other scenarios will not |
| * be considered |
| * @param multipleInstances |
| * Whether multiple scenarios are allowed for this state machine |
| */ |
| public DataDrivenFsm(String id, DataDrivenFsmState initial, Map<String, DataDrivenFsmSimpleState> states, DataDrivenCondition preCondition, boolean consuming, boolean multipleInstances) { |
| super(id); |
| fInitial = initial; |
| fStates = states; |
| fPrecondition = preCondition; |
| fConsuming = consuming; |
| fMultipleInstances = multipleInstances; |
| } |
| |
| /** |
| * Create a new scenario for this FSM |
| * |
| * @param event |
| * The event that marks the start of the scenario |
| * @param force |
| * Whether to force the creation or create only if allowed |
| * @param executionData |
| * The execution data |
| * @param container |
| * The parent analysis container |
| */ |
| public void createScenario(ITmfEvent event, boolean force, DataDrivenRuntimeData executionData, IAnalysisDataContainer container) { |
| DataDrivenRuntimeFsm runtimeFsm = executionData.getRuntimeForFsm(this); |
| if (force || isNewScenarioAllowed(runtimeFsm)) { |
| runtimeFsm.addPendingScenario(new DataDrivenScenario(event, this, fInitial, container, executionData)); |
| } |
| } |
| |
| /** |
| * Return whether this finite state machine can support an additional |
| * scenario |
| * |
| * @param runtimeFsm |
| * The runtime FSM data |
| * @return <code>true</code> if this state machine can have a new scenario |
| */ |
| public synchronized boolean isNewScenarioAllowed(DataDrivenRuntimeFsm runtimeFsm) { |
| return runtimeFsm.getScenarioCount() > 0 && fMultipleInstances |
| && runtimeFsm.getPendingScenario() == null; |
| } |
| |
| /** |
| * Let the FSM try to handle this event |
| * |
| * @param event |
| * The event to handle |
| * @param executionData |
| * The execution data for run |
| * @param container |
| * The analysis data container |
| */ |
| public void handleEvent(ITmfEvent event, DataDrivenRuntimeData executionData, IAnalysisDataContainer container) { |
| // First validate the precondition |
| // Preconditions should be stateless, so we don't need specific scenario |
| // infos |
| if (!fPrecondition.test(event, DataDrivenScenarioInfo.DUMMY_SCENARIO, container)) { |
| return; |
| } |
| |
| DataDrivenRuntimeFsm runtimeFsm = executionData.getRuntimeForFsm(this); |
| boolean eventConsumed = false; |
| |
| // First handle the active scenarios |
| eventConsumed = handleActiveScenarios(event, runtimeFsm, container); |
| // Then handle the pending scenario |
| handlePendingScenario(event, eventConsumed, runtimeFsm, container); |
| } |
| |
| private void handlePendingScenario(ITmfEvent event, boolean eventConsumed, DataDrivenRuntimeFsm runtimeFsm, IAnalysisDataContainer container) { |
| if (fConsuming && eventConsumed) { |
| return; |
| } |
| |
| DataDrivenScenario scenario = runtimeFsm.getPendingScenario(); |
| if (scenario != null) { |
| scenario.handleEvent(event, container); |
| if (!scenario.isPending()) { |
| runtimeFsm.activatePending(); |
| } |
| } |
| } |
| |
| /** |
| * Process the active scenario with the ongoing event |
| * |
| * @param event |
| * The ongoing event |
| * @param runtimeFsm |
| * The map of transition |
| * @param container |
| * The data container |
| * @return True if the event has been consumed by the active scenarios |
| */ |
| private boolean handleActiveScenarios(ITmfEvent event, DataDrivenRuntimeFsm runtimeFsm, IAnalysisDataContainer container) { |
| |
| boolean eventConsumed = false; |
| List<DataDrivenScenario> toRemove = new ArrayList<>(); |
| for (DataDrivenScenario scenario : runtimeFsm.getActiveScenarios()) { |
| // Remove inactive scenarios or handle the active ones. |
| if (!scenario.isActive()) { |
| toRemove.add(scenario); |
| } else { |
| if (scenario.isActive() || scenario.isPending()) { |
| eventConsumed |= scenario.handleEvent(event, container); |
| if (fConsuming && eventConsumed) { |
| break; |
| } |
| } |
| } |
| } |
| // Remove scenarios set to be removed |
| for (DataDrivenScenario scenario : toRemove) { |
| runtimeFsm.removeScenario(scenario); |
| } |
| |
| return eventConsumed; |
| |
| } |
| |
| /** |
| * Cancel all the still active scenarios |
| * |
| * @param executionData |
| * The execution data |
| */ |
| public void dispose(DataDrivenRuntimeData executionData) { |
| for (DataDrivenScenario scenario : executionData.getRuntimeForFsm(this).getActiveScenarios()) { |
| if (scenario.isActive()) { |
| scenario.cancel(); |
| } |
| } |
| } |
| |
| /** |
| * Get the state of a given name. The state should exist and this method |
| * will throw a <code>NullPointerException</code> if it doesn't. |
| * |
| * @param stateName |
| * The name of the state to get |
| * @return The requested state |
| */ |
| public DataDrivenFsmSimpleState getState(String stateName) { |
| return Objects.requireNonNull(fStates.get(stateName), "The requested state should exist"); //$NON-NLS-1$ |
| } |
| |
| @Override |
| public int hashCode() { |
| return Objects.hash(super.hashCode(), fInitial, fStates, fPrecondition, fConsuming, fMultipleInstances); |
| } |
| |
| @Override |
| public boolean equals(@Nullable Object obj) { |
| if (!(obj instanceof DataDrivenFsm)) { |
| return false; |
| } |
| DataDrivenFsm other = (DataDrivenFsm) obj; |
| return super.equals(obj) && |
| Objects.equals(fInitial, other.fInitial) && |
| Objects.equals(fPrecondition, other.fPrecondition) && |
| Objects.equals(fConsuming, other.fConsuming) && |
| Objects.equals(fMultipleInstances, other.fMultipleInstances) && |
| Objects.equals(fStates, other.fStates); |
| } |
| |
| @Override |
| public String toString() { |
| return "FSM " + getId() + ':' + fInitial + ' ' + fPrecondition + ' ' + fConsuming + ' ' + fMultipleInstances + //$NON-NLS-1$ |
| ' ' + fStates; |
| } |
| |
| } |
