| /******************************************************************************* |
| * Copyright (c) 2017 É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 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.runtime.DataDrivenScenarioInfo; |
| import org.eclipse.tracecompass.internal.tmf.analysis.xml.core.fsm.model.values.DataDrivenValue; |
| import org.eclipse.tracecompass.internal.tmf.analysis.xml.core.fsm.module.IAnalysisDataContainer; |
| import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem; |
| import org.eclipse.tracecompass.statesystem.core.ITmfStateSystemBuilder; |
| import org.eclipse.tracecompass.tmf.analysis.xml.core.module.TmfXmlStrings; |
| import org.eclipse.tracecompass.tmf.analysis.xml.core.module.TmfXmlUtils; |
| import org.eclipse.tracecompass.tmf.core.event.ITmfEvent; |
| import org.eclipse.tracecompass.tmf.core.statesystem.ITmfStateProvider.FutureEventType; |
| |
| /** |
| * An action that assigns a value to a path in a state system |
| * |
| * @author Geneviève Bastien |
| * @author Florian Wininger |
| */ |
| public class DataDrivenActionStateChange implements DataDrivenAction { |
| |
| /** |
| * An enumeration of possible actions on stack |
| */ |
| public enum StackAction { |
| /** No action */ |
| NONE, |
| /** Push a value to the stack */ |
| PUSH, |
| /** Peek the top of a stack */ |
| PEEK, |
| /** Pop a value from a stack */ |
| POP, |
| /** Pops all the values from the stack */ |
| POP_ALL; |
| |
| /** |
| * Get the type stack value corresponding to a string |
| * |
| * @param input |
| * The string to match to a value |
| * @return The ValueTypeStack value |
| */ |
| public static StackAction getTypeFromString(String input) { |
| switch (input) { |
| case TmfXmlStrings.STACK_PUSH: |
| return PUSH; |
| case TmfXmlStrings.STACK_POP: |
| return POP; |
| case TmfXmlStrings.STACK_POPALL: |
| return POP_ALL; |
| case TmfXmlStrings.STACK_PEEK: |
| return PEEK; |
| default: |
| return NONE; |
| } |
| } |
| } |
| |
| private final DataDrivenValue fRightOperand; |
| private final DataDrivenStateSystemPath fLeftOperand; |
| // private final List<DataDrivenValue> fLeftOperand; |
| private final boolean fUpdate; |
| private final boolean fIncrement; |
| private final StackAction fStackAction; |
| private final @Nullable DataDrivenValue fFutureTime; |
| |
| /** |
| * Constructor |
| * |
| * @param leftOperand |
| * The left operands (path in the state system) |
| * @param rightOperand |
| * The right operand, ie the value to assign |
| * @param increment |
| * If <code>true</code>, the value of the right operand will be added |
| * to the preceding value |
| * @param update |
| * If <code>true</code>, the resulting value will be updated and will |
| * not create a state change, otherwise, the value will be modified |
| * and a new state will start at the time of the event. |
| * @param stackAction |
| * The action to perform on a stack |
| * @param futureTime |
| * The state value for the future time. If the state change happens |
| * at the time of the event, this value should be null |
| */ |
| public DataDrivenActionStateChange(DataDrivenStateSystemPath leftOperand, DataDrivenValue rightOperand, boolean increment, boolean update, StackAction stackAction, @Nullable DataDrivenValue futureTime) { |
| fRightOperand = rightOperand; |
| fLeftOperand = leftOperand; |
| fUpdate = update; |
| fIncrement = increment; |
| fStackAction = stackAction; |
| fFutureTime = futureTime; |
| } |
| |
| @Override |
| public void eventHandle(ITmfEvent event, DataDrivenScenarioInfo scenarioInfo, IAnalysisDataContainer container) { |
| int quark = ITmfStateSystem.ROOT_ATTRIBUTE; |
| ITmfStateSystem stateSystem = container.getStateSystem(); |
| if (!(stateSystem instanceof ITmfStateSystemBuilder)) { |
| throw new IllegalStateException("With state changes, the state system should be in building mode"); //$NON-NLS-1$ |
| } |
| ITmfStateSystemBuilder ssb = (ITmfStateSystemBuilder) stateSystem; |
| |
| // Get the quark that will be changed |
| quark = fLeftOperand.getQuark(event, quark, scenarioInfo, container); |
| if (quark < 0) { |
| return; |
| } |
| |
| // Get the value |
| Object assignVal = fRightOperand.getValue(event, ITmfStateSystem.ROOT_ATTRIBUTE, scenarioInfo, container); |
| |
| long timestamp = event.getTimestamp().toNanos(); |
| // Should this state change be done at a future time? |
| long scTime = timestamp; |
| if (fFutureTime != null) { |
| Object futureTimeObj = fFutureTime.getValue(event, ITmfStateSystem.ROOT_ATTRIBUTE, scenarioInfo, container); |
| if (futureTimeObj instanceof Number) { |
| scTime = ((Number) futureTimeObj).longValue(); |
| } else { |
| try { |
| // Try parsing the value |
| scTime = Long.parseLong(String.valueOf(futureTimeObj)); |
| } catch (NumberFormatException e) { |
| try { |
| // Maybe it's a double, XML scripts return double for |
| // instance |
| scTime = Double.valueOf(Double.parseDouble(String.valueOf(futureTimeObj))).longValue(); |
| } catch (NumberFormatException e1) { |
| // Cannot convert to number, ignore |
| } |
| } |
| } |
| } |
| |
| // Perform the stack action if applicable and return |
| switch (fStackAction) { |
| case POP: |
| if (scTime > timestamp) { |
| container.addFutureState(scTime, assignVal, quark, FutureEventType.POP); |
| } else { |
| ssb.popAttribute(timestamp, quark); |
| } |
| return; |
| case PUSH: |
| if (scTime > timestamp) { |
| container.addFutureState(scTime, assignVal, quark, FutureEventType.PUSH); |
| } else { |
| ssb.pushAttribute(timestamp, assignVal, quark); |
| } |
| return; |
| case POP_ALL: |
| // The stack state will contain the number of elements on the stack |
| Object stackDepth = ssb.queryOngoing(quark); |
| if (stackDepth instanceof Integer) { |
| int nbElements = ((Integer) stackDepth).intValue(); |
| for (int i = 0; i < nbElements; i++) { |
| if (scTime > timestamp) { |
| container.addFutureState(scTime, assignVal, quark, FutureEventType.POP); |
| } else { |
| ssb.popAttribute(timestamp, quark); |
| } |
| } |
| } |
| return; |
| case NONE: |
| case PEEK: |
| default: |
| break; |
| } |
| |
| // Increment if necessary |
| if (fIncrement && assignVal != null) { |
| assignVal = incrementByType(quark, ssb, assignVal); |
| } |
| |
| // If update is requested, do update and return |
| if (fUpdate) { |
| ssb.updateOngoingState(TmfXmlUtils.newTmfStateValueFromObject(assignVal), quark); |
| } else if (scTime == timestamp) { |
| ssb.modifyAttribute(timestamp, assignVal, quark); |
| } else if (scTime > timestamp) { |
| container.addFutureState(scTime, assignVal, quark, FutureEventType.MODIFICATION); |
| } else { |
| Activator.logWarning("No state change occurred for event " + event + " and state change " + this + ". The time of the change is invalid: " + scTime); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$ |
| } |
| } |
| |
| private static @Nullable Object incrementByType(int quark, ITmfStateSystem ss, Object stateValue) { |
| if (stateValue instanceof Long) { |
| Long incrementLong = (Long) stateValue; |
| Object currentState = ss.queryOngoing(quark); |
| Long currentValue = (currentState == null ? 0 : (Long) currentState); |
| return incrementLong + currentValue; |
| } |
| if (stateValue instanceof Integer) { |
| Integer incrementLong = (Integer) stateValue; |
| Object currentState = ss.queryOngoing(quark); |
| Integer currentValue = (currentState == null ? 0 : (Integer) currentState); |
| return incrementLong + currentValue; |
| } |
| return stateValue; |
| } |
| |
| } |
