[deliverable/tracecompass.git] / tmf / org.eclipse.tracecompass.tmf.analysis.xml.core / src / org / eclipse / tracecompass / internal / tmf / analysis / xml / core / model / TmfXmlStateValue.java

/*******************************************************************************
 * Copyright (c) 2014, 2015 Ecole Polytechnique de Montreal
 *
 * All rights reserved. This program and the accompanying materials are
 * made available under the terms of the Eclipse Public License v1.0 which
 * accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   Florian Wininger - Initial API and implementation
 ******************************************************************************/

package org.eclipse.tracecompass.internal.tmf.analysis.xml.core.model;

import java.util.List;
import java.util.Set;

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.module.IXmlStateSystemContainer;
import org.eclipse.tracecompass.internal.tmf.analysis.xml.core.pattern.stateprovider.XmlPatternStateProvider;
import org.eclipse.tracecompass.internal.tmf.analysis.xml.core.stateprovider.TmfXmlStrings;
import org.eclipse.tracecompass.internal.tmf.analysis.xml.core.stateprovider.XmlStateProvider;
import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem;
import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException;
import org.eclipse.tracecompass.statesystem.core.exceptions.StateValueTypeException;
import org.eclipse.tracecompass.statesystem.core.exceptions.TimeRangeException;
import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue;
import org.eclipse.tracecompass.statesystem.core.statevalue.TmfStateValue;
import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
import org.eclipse.tracecompass.tmf.core.event.ITmfEventField;
import org.eclipse.tracecompass.tmf.core.event.aspect.TmfCpuAspect;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
import org.w3c.dom.Element;

/**
 * This Class implements a State Value in the XML-defined state system, along
 * with the path to get to the value (either a list of state attributes or an
 * event field)
 *
 * <pre>
 * Example:
 *   <stateAttribute type="location" value="CurrentThread" />
 *   <stateAttribute type="constant" value="System_call" />
 *   <stateValue type="null" />
 * </pre>
 *
 * @author Florian Wininger
 */
public abstract class TmfXmlStateValue implements ITmfXmlStateValue {

    private final TmfXmlStateValueBase fStateValue;

    /* Path in the State System */
    private final List<ITmfXmlStateAttribute> fPath;
    /* Event field to match with this state value */
    private final @Nullable String fEventField;

    /* Whether this state value is an increment of the previous value */
    private final boolean fIncrement;
    /* Whether to update the current attribute or create a new state */
    private final boolean fUpdate;
    /* Stack value */
    private final ValueTypeStack fStackType;
    /* Forced value type */
    private final ITmfStateValue.Type fForcedType;

    private final IXmlStateSystemContainer fContainer;

    private final String fMappingGroup;

    /**
     * Different behaviors of an attribute that is to be stacked
     */
    protected enum ValueTypeStack {
        /** Not stacked */
        NULL,
        /** Peek at the value at the top of the stack */
        PEEK,
        /** Take the value at the top of the stack */
        POP,
        /** Push the value on the stack */
        PUSH;

        /**
         * Get the type stack value corresponding to a string
         *
         * @param input
         *            The string to match to a value
         * @return The ValueTypeStack value
         */
        public static ValueTypeStack getTypeFromString(String input) {
            switch (input) {
            case TmfXmlStrings.STACK_PUSH:
                return PUSH;
            case TmfXmlStrings.STACK_POP:
                return POP;
            case TmfXmlStrings.STACK_PEEK:
                return PEEK;
            default:
                return NULL;
            }
        }
    }

    /**
     * Constructor
     *
     * @param modelFactory
     *            The factory used to create XML model elements
     * @param node
     *            The state value XML element
     * @param container
     *            The state system container this state value belongs to
     * @param eventField
     *            The event field where to get the value
     * @param attributes
     *            The attributes representing the path to this value
     */
    protected TmfXmlStateValue(ITmfXmlModelFactory modelFactory, Element node, IXmlStateSystemContainer container, List<ITmfXmlStateAttribute> attributes, @Nullable String eventField) {
        fPath = attributes;
        fContainer = container;
        fEventField = eventField;
        if (!node.getNodeName().equals(TmfXmlStrings.STATE_VALUE)) {
            throw new IllegalArgumentException("TmfXmlStateValue constructor: Element is not a stateValue"); //$NON-NLS-1$
        }

        /* Check if there is an increment for the value */
        fIncrement = Boolean.parseBoolean(node.getAttribute(TmfXmlStrings.INCREMENT));

        /* Check if this value is an update of the ongoing state */
        fUpdate = Boolean.parseBoolean(node.getAttribute(TmfXmlStrings.UPDATE));

        /* Process the XML Element state value */
        fStateValue = initializeStateValue(modelFactory, node);

        /*
         * Forced type allows to convert the value to a certain type : For
         * example, a process's TID in an event field may arrive with a LONG
         * format but we want to store the data in an INT
         */
        switch (node.getAttribute(TmfXmlStrings.FORCED_TYPE)) {
        case TmfXmlStrings.TYPE_STRING:
            fForcedType = ITmfStateValue.Type.STRING;
            break;
        case TmfXmlStrings.TYPE_INT:
            fForcedType = ITmfStateValue.Type.INTEGER;
            break;
        case TmfXmlStrings.TYPE_LONG:
            fForcedType = ITmfStateValue.Type.LONG;
            break;
        case TmfXmlStrings.TYPE_DOUBLE:
            fForcedType = ITmfStateValue.Type.DOUBLE;
            break;
        default:
            fForcedType = ITmfStateValue.Type.NULL;
        }

        /*
         * Stack Actions : allow to define a stack with PUSH/POP/PEEK methods
         */
        String stack = node.getAttribute(TmfXmlStrings.ATTRIBUTE_STACK);
        fStackType = ValueTypeStack.getTypeFromString(stack);

        fMappingGroup = node.getAttribute(TmfXmlStrings.MAPPING_GROUP);
    }

    /**
     * Initialize a {@link TmfXmlStateValueBase} object for the type and value
     *
     * @param modelFactory
     *            The factory used to create XML model elements
     * @param node
     *            The state value XML element
     * @return The internal state value type corresponding to this state value
     */
    protected TmfXmlStateValueBase initializeStateValue(ITmfXmlModelFactory modelFactory, Element node) {
        return new TmfXmlStateValueNull();
    }

    /**
     * Return the state system container this class is attached to
     *
     * @return The state system container
     */
    protected IXmlStateSystemContainer getSsContainer() {
        return fContainer;
    }

    /**
     * Get the state system associated with this value's container
     *
     * @return The state system associated with the state system container
     */
    protected @Nullable ITmfStateSystem getStateSystem() {
        return fContainer.getStateSystem();
    }

    /**
     * Return whether this value is an increment of the previous value
     *
     * @return <code>true</code> if the value is an increment
     */
    protected boolean isIncrement() {
        return fIncrement;
    }

    /**
     * Return whether this value should replace the current value of the
     * attribute or if a new state should be created.
     *
     * @return <code>true</code> if the value is to replace the current one
     */
    protected boolean isUpdate() {
        return fUpdate;
    }

    /**
     * Get the stack type of this attribute. If the attribute is to be pushed or
     * popped to a stack. The behavior of the stack attribute will depend on the
     * implementation of the model.
     *
     * @return The stack type of the attribute
     */
    protected ValueTypeStack getStackType() {
        return fStackType;
    }

    /**
     * Get the forced type of the value. For example, if the value obtained from
     * the attributes is not in this forced type, it will be converted to this.
     *
     * @return The desired type of the value
     */
    protected ITmfStateValue.Type getForcedType() {
        return fForcedType;
    }

    @Override
    public ITmfStateValue getValue(@Nullable ITmfEvent event, @Nullable TmfXmlScenarioInfo scenarioInfo) throws AttributeNotFoundException {
        return getMappedValue(event, scenarioInfo, fStateValue.getValue(event, scenarioInfo));
    }

    private ITmfStateValue getMappedValue(@Nullable ITmfEvent event, @Nullable TmfXmlScenarioInfo scenarioInfo, ITmfStateValue value) {
        try {
            Set<TmfXmlMapEntry> group = null;
            if (fContainer instanceof XmlPatternStateProvider) {
                group = ((XmlPatternStateProvider) fContainer).getMappingGroup(fMappingGroup);
            } else if (fContainer instanceof XmlStateProvider) {
                group = ((XmlStateProvider) fContainer).getMappingGroup(fMappingGroup);
            }
            if (group != null) {
                for (TmfXmlMapEntry entry : group) {
                    if (entry.getKey().getValue(event, scenarioInfo).equals(value)) {
                        return entry.getValue().getValue(event, scenarioInfo);
                    }
                }
            }
            return value;
        } catch (AttributeNotFoundException e) {
            Activator.logError("Unable to map the state value"); //$NON-NLS-1$
            // FIXME maybe we should return the raw state value instead of a
            // null state value
            return TmfStateValue.nullValue();
        }
    }

    /**
     * Get the value of the event field that is the path of this state value
     *
     * @param event
     *            The current event
     * @return the value of the event field
     */
    @Override
    public ITmfStateValue getEventFieldValue(@NonNull ITmfEvent event) {
        String eventField = fEventField;
        if (eventField == null) {
            throw new IllegalStateException();
        }
        return getEventFieldValue(event, eventField);
    }

    /**
     * Get the value of an event field
     *
     * @param event
     *            The current event
     * @param fieldName
     *            The name of the field of which to get the value
     * @return The value of the event field
     */
    protected ITmfStateValue getEventFieldValue(ITmfEvent event, String fieldName) {

        ITmfStateValue value = TmfStateValue.nullValue();

        final ITmfEventField field = event.getContent().getField(fieldName);

        /* If the field does not exist, see if it's a special case */
        if (field == null) {

            if (fieldName.equalsIgnoreCase(TmfXmlStrings.CPU)) {
                /* A "CPU" field will return the CPU aspect if available */
                Integer cpu = TmfTraceUtils.resolveIntEventAspectOfClassForEvent(event.getTrace(), TmfCpuAspect.class, event);
                if (cpu != null) {
                    return TmfStateValue.newValueInt(cpu.intValue());
                }
            } else if (fieldName.equalsIgnoreCase(TmfXmlStrings.TIMESTAMP)) {
                /*
                 * Exception also for "TIMESTAMP", returns the timestamp of this
                 * event
                 */
                return TmfStateValue.newValueLong(event.getTimestamp().getValue());
            }
            return value;
        }

        Object fieldValue = field.getValue();

        /*
         * Try to find the right type. The type can be forced by
         * "forcedType" argument.
         */

        if (fieldValue instanceof String) {
            String fieldString = (String) fieldValue;

            switch (fForcedType) {
            case INTEGER:
                value = TmfStateValue.newValueInt(Integer.parseInt(fieldString));
                break;
            case LONG:
                value = TmfStateValue.newValueLong(Long.parseLong(fieldString));
                break;
            case DOUBLE:
                value = TmfStateValue.newValueDouble(Double.parseDouble(fieldString));
                break;
            case CUSTOM:
                throw new IllegalStateException("Custom type cannot be forced"); //$NON-NLS-1$
            case NULL:
            case STRING:
            default:
                value = TmfStateValue.newValueString(fieldString);
                break;
            }
        } else if (fieldValue instanceof Long) {
            Long fieldLong = (Long) fieldValue;

            switch (fForcedType) {
            case INTEGER:
                value = TmfStateValue.newValueInt(fieldLong.intValue());
                break;
            case STRING:
                value = TmfStateValue.newValueString(fieldLong.toString());
                break;
            case DOUBLE:
                value = TmfStateValue.newValueDouble(fieldLong.doubleValue());
                break;
            case CUSTOM:
                throw new IllegalStateException("Custom type cannot be forced"); //$NON-NLS-1$
            case LONG:
            case NULL:
            default:
                value = TmfStateValue.newValueLong(fieldLong);
                break;
            }
        } else if (fieldValue instanceof Integer) {
            Integer fieldInteger = (Integer) fieldValue;

            switch (fForcedType) {
            case LONG:
                value = TmfStateValue.newValueLong(fieldInteger.longValue());
                break;
            case STRING:
                value = TmfStateValue.newValueString(fieldInteger.toString());
                break;
            case DOUBLE:
                value = TmfStateValue.newValueDouble(fieldInteger.doubleValue());
                break;
            case CUSTOM:
                throw new IllegalStateException("Custom type cannot be forced"); //$NON-NLS-1$
            case INTEGER:
            case NULL:
            default:
                value = TmfStateValue.newValueInt(fieldInteger);
                break;
            }
        } else if (fieldValue instanceof Double) {
            Double fieldDouble = (Double) fieldValue;

            switch (fForcedType) {
            case LONG:
                value = TmfStateValue.newValueLong(fieldDouble.longValue());
                break;
            case STRING:
                value = TmfStateValue.newValueString(fieldDouble.toString());
                break;
            case INTEGER:
                value = TmfStateValue.newValueInt(fieldDouble.intValue());
                break;
            case CUSTOM:
                throw new IllegalStateException("Custom type cannot be forced"); //$NON-NLS-1$
            case DOUBLE:
            case NULL:
            default:
                value = TmfStateValue.newValueDouble(fieldDouble);
                break;
            }
        }
        return value;
    }

    /**
     * Get the list of state attributes, the path to the state value
     *
     * @return the list of Attribute to have the path in the State System
     */
    @Override
    public List<ITmfXmlStateAttribute> getAttributes() {
        return fPath;
    }

    @Override
    public void handleEvent(@NonNull ITmfEvent event, @Nullable TmfXmlScenarioInfo scenarioInfo) throws AttributeNotFoundException, StateValueTypeException, TimeRangeException {
        int quark = IXmlStateSystemContainer.ROOT_QUARK;

        for (ITmfXmlStateAttribute attribute : fPath) {
            quark = attribute.getAttributeQuark(event, quark, scenarioInfo);
            /* the query is not valid, we stop the state change */
            if (quark == IXmlStateSystemContainer.ERROR_QUARK) {
                Activator.logError("Not found XML attribute " + attribute); //$NON-NLS-1$
                return;
            }
        }

        long ts = event.getTimestamp().getValue();
        fStateValue.handleEvent(event, quark, ts, scenarioInfo);
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder("TmfXmlStateValue: "); //$NON-NLS-1$
        if (fEventField != null) {
            builder.append("Field=").append(fEventField).append("; "); //$NON-NLS-1$ //$NON-NLS-2$
        } else if (!fPath.isEmpty()) {
            builder.append("Path=").append(fPath).append("; "); //$NON-NLS-1$ //$NON-NLS-2$
        }
        builder.append(fStateValue);
        return builder.toString();
    }

    /**
     * Base class for all state values. Contain default methods to handle event,
     * process or increment the value
     */
    protected abstract class TmfXmlStateValueBase {

        /**
         * Get the value associated with this state value.
         *
         * @param event
         *            The event which can be used to retrieve the value if
         *            necessary. The event can be <code>null</code> if no event
         *            is required.
         * @param scenarioInfo
         *            The active scenario details. The value should be null if
         *            there no scenario.
         * @return The state value corresponding to this XML state value
         * @throws AttributeNotFoundException
         *             Pass through the exception it received
         */
        public abstract ITmfStateValue getValue(@Nullable ITmfEvent event, @Nullable TmfXmlScenarioInfo scenarioInfo) throws AttributeNotFoundException;

        /**
         * Do something with the state value, possibly using an event
         *
         * @param event
         *            The event being handled. If there is no event is
         *            available, use <code>null</code>.
         * @param quark
         *            The quark for this value
         * @param timestamp
         *            The timestamp of the event
         * @param scenarioInfo
         *            The active scenario details. The value should be null if
         *            there no scenario.
         * @throws StateValueTypeException
         *             Pass through the exception it received
         * @throws TimeRangeException
         *             Pass through the exception it received
         * @throws AttributeNotFoundException
         *             Pass through the exception it received
         */
        public void handleEvent(ITmfEvent event, int quark, long timestamp, @Nullable TmfXmlScenarioInfo scenarioInfo) throws StateValueTypeException, TimeRangeException, AttributeNotFoundException {
            if (fIncrement) {
                incrementValue(event, quark, timestamp, scenarioInfo);
            } else {
                ITmfStateValue value = getValue(event, scenarioInfo);
                processValue(quark, timestamp, value);
            }
        }

        /**
         * Set the value of a quark at a given timestamp.
         *
         * @param quark
         *            The quark for this value
         * @param timestamp
         *            The timestamp
         * @param value
         *            The value of this state value
         * @throws TimeRangeException
         *             Pass through the exception it received
         * @throws StateValueTypeException
         *             Pass through the exception it received
         * @throws AttributeNotFoundException
         *             Pass through the exception it received
         */
        @SuppressWarnings("unused")
        protected void processValue(int quark, long timestamp, ITmfStateValue value) throws TimeRangeException, StateValueTypeException, AttributeNotFoundException {
        }

        /**
         * Increments the value of the parameter
         *
         * @param event
         *            The event being handled
         * @param quark
         *            The quark for this value
         * @param timestamp
         *            The timestamp of the event
         * @param scenarioInfo
         *            The active scenario details. The value should be null if
         *            there no scenario.
         * @throws StateValueTypeException
         *             Pass through the exception it received
         * @throws TimeRangeException
         *             Pass through the exception it received
         * @throws AttributeNotFoundException
         *             Pass through the exception it received
         */
        @SuppressWarnings("unused")
        protected void incrementValue(ITmfEvent event, int quark, long timestamp, @Nullable TmfXmlScenarioInfo scenarioInfo) throws StateValueTypeException, TimeRangeException, AttributeNotFoundException {
        }
    }

    /* This state value uses a constant value, defined in the XML */
    private class TmfXmlStateValueNull extends TmfXmlStateValueBase {

        @Override
        public ITmfStateValue getValue(@Nullable ITmfEvent event, @Nullable TmfXmlScenarioInfo scenarioInfo) throws AttributeNotFoundException {
            return TmfStateValue.nullValue();
        }

        @Override
        public String toString() {
            return "NULL"; //$NON-NLS-1$
        }
    }

}
Commit	Line	Data
1d7e62f9	1	/*******************************************************************************
ed902a2b	2	* Copyright (c) 2014, 2015 Ecole Polytechnique de Montreal
1d7e62f9 GB	3	*
	4	* All rights reserved. This program and the accompanying materials are
	5	* made available under the terms of the Eclipse Public License v1.0 which
	6	* accompanies this distribution, and is available at
	7	* http://www.eclipse.org/legal/epl-v10.html
	8	*
	9	* Contributors:
	10	* Florian Wininger - Initial API and implementation
	11	******************************************************************************/
	12
6eca054d	13	package org.eclipse.tracecompass.internal.tmf.analysis.xml.core.model;
1d7e62f9 GB	14
1d7e62f9 GB	15	import java.util.List;
55df9717	16	import java.util.Set;
1d7e62f9 GB	17
	18	import org.eclipse.jdt.annotation.NonNull;
	19	import org.eclipse.jdt.annotation.Nullable;
cf5a64e1	20	import org.eclipse.tracecompass.internal.tmf.analysis.xml.core.Activator;
6eca054d	21	import org.eclipse.tracecompass.internal.tmf.analysis.xml.core.module.IXmlStateSystemContainer;
55df9717	22	import org.eclipse.tracecompass.internal.tmf.analysis.xml.core.pattern.stateprovider.XmlPatternStateProvider;
6eca054d	23	import org.eclipse.tracecompass.internal.tmf.analysis.xml.core.stateprovider.TmfXmlStrings;
55df9717	24	import org.eclipse.tracecompass.internal.tmf.analysis.xml.core.stateprovider.XmlStateProvider;
e894a508 AM	25	import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem;
	26	import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException;
	27	import org.eclipse.tracecompass.statesystem.core.exceptions.StateValueTypeException;
	28	import org.eclipse.tracecompass.statesystem.core.exceptions.TimeRangeException;
	29	import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue;
	30	import org.eclipse.tracecompass.statesystem.core.statevalue.TmfStateValue;
2bdf0193 AM	31	import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
2bdf0193 AM	32	import org.eclipse.tracecompass.tmf.core.event.ITmfEventField;
35f39420 AM	33	import org.eclipse.tracecompass.tmf.core.event.aspect.TmfCpuAspect;
35f39420 AM	34	import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
1d7e62f9 GB	35	import org.w3c.dom.Element;
	36
	37	/**
	38	* This Class implements a State Value in the XML-defined state system, along
	39	* with the path to get to the value (either a list of state attributes or an
	40	* event field)
	41	*
	42	* <pre>
	43	* Example:
	44	* <stateAttribute type="location" value="CurrentThread" />
	45	* <stateAttribute type="constant" value="System_call" />
	46	* <stateValue type="null" />
	47	* </pre>
	48	*
	49	* @author Florian Wininger
	50	*/
	51	public abstract class TmfXmlStateValue implements ITmfXmlStateValue {
	52
	53	private final TmfXmlStateValueBase fStateValue;
	54
	55	/* Path in the State System */
	56	private final List<ITmfXmlStateAttribute> fPath;
	57	/* Event field to match with this state value */
12685851	58	private final @Nullable String fEventField;
1d7e62f9 GB	59
	60	/* Whether this state value is an increment of the previous value */
	61	private final boolean fIncrement;
8ab1a965 GB	62	/* Whether to update the current attribute or create a new state */
8ab1a965 GB	63	private final boolean fUpdate;
1d7e62f9 GB	64	/* Stack value */
	65	private final ValueTypeStack fStackType;
	66	/* Forced value type */
	67	private final ITmfStateValue.Type fForcedType;
	68
	69	private final IXmlStateSystemContainer fContainer;
	70
55df9717 JCK	71	private final String fMappingGroup;
55df9717 JCK	72
1d7e62f9 GB	73	/**
	74	* Different behaviors of an attribute that is to be stacked
	75	*/
	76	protected enum ValueTypeStack {
	77	/** Not stacked */
	78	NULL,
	79	/** Peek at the value at the top of the stack */
	80	PEEK,
	81	/** Take the value at the top of the stack */
	82	POP,
	83	/** Push the value on the stack */
	84	PUSH;
	85
	86	/**
	87	* Get the type stack value corresponding to a string
	88	*
	89	* @param input
	90	* The string to match to a value
	91	* @return The ValueTypeStack value
	92	*/
	93	public static ValueTypeStack getTypeFromString(String input) {
	94	switch (input) {
	95	case TmfXmlStrings.STACK_PUSH:
	96	return PUSH;
	97	case TmfXmlStrings.STACK_POP:
	98	return POP;
	99	case TmfXmlStrings.STACK_PEEK:
	100	return PEEK;
	101	default:
	102	return NULL;
	103	}
	104	}
	105	}
	106
	107	/**
	108	* Constructor
	109	*
	110	* @param modelFactory
	111	* The factory used to create XML model elements
	112	* @param node
	113	* The state value XML element
	114	* @param container
	115	* The state system container this state value belongs to
	116	* @param eventField
	117	* The event field where to get the value
	118	* @param attributes
	119	* The attributes representing the path to this value
	120	*/
12685851	121	protected TmfXmlStateValue(ITmfXmlModelFactory modelFactory, Element node, IXmlStateSystemContainer container, List<ITmfXmlStateAttribute> attributes, @Nullable String eventField) {
1d7e62f9 GB	122	fPath = attributes;
	123	fContainer = container;
	124	fEventField = eventField;
	125	if (!node.getNodeName().equals(TmfXmlStrings.STATE_VALUE)) {
	126	throw new IllegalArgumentException("TmfXmlStateValue constructor: Element is not a stateValue"); //$NON-NLS-1$
	127	}
	128
	129	/* Check if there is an increment for the value */
	130	fIncrement = Boolean.parseBoolean(node.getAttribute(TmfXmlStrings.INCREMENT));
	131
8ab1a965 GB	132	/* Check if this value is an update of the ongoing state */
	133	fUpdate = Boolean.parseBoolean(node.getAttribute(TmfXmlStrings.UPDATE));
	134
1d7e62f9 GB	135	/* Process the XML Element state value */
	136	fStateValue = initializeStateValue(modelFactory, node);
	137
	138	/*
	139	* Forced type allows to convert the value to a certain type : For
	140	* example, a process's TID in an event field may arrive with a LONG
	141	* format but we want to store the data in an INT
	142	*/
	143	switch (node.getAttribute(TmfXmlStrings.FORCED_TYPE)) {
	144	case TmfXmlStrings.TYPE_STRING:
	145	fForcedType = ITmfStateValue.Type.STRING;
	146	break;
	147	case TmfXmlStrings.TYPE_INT:
	148	fForcedType = ITmfStateValue.Type.INTEGER;
	149	break;
	150	case TmfXmlStrings.TYPE_LONG:
	151	fForcedType = ITmfStateValue.Type.LONG;
	152	break;
425e1cfa BH	153	case TmfXmlStrings.TYPE_DOUBLE:
	154	fForcedType = ITmfStateValue.Type.DOUBLE;
	155	break;
1d7e62f9 GB	156	default:
	157	fForcedType = ITmfStateValue.Type.NULL;
	158	}
	159
	160	/*
	161	* Stack Actions : allow to define a stack with PUSH/POP/PEEK methods
	162	*/
0e4f957e	163	String stack = node.getAttribute(TmfXmlStrings.ATTRIBUTE_STACK);
1d7e62f9	164	fStackType = ValueTypeStack.getTypeFromString(stack);
55df9717 JCK	165
55df9717 JCK	166	fMappingGroup = node.getAttribute(TmfXmlStrings.MAPPING_GROUP);
1d7e62f9 GB	167	}
	168
	169	/**
	170	* Initialize a {@link TmfXmlStateValueBase} object for the type and value
	171	*
	172	* @param modelFactory
	173	* The factory used to create XML model elements
	174	* @param node
	175	* The state value XML element
	176	* @return The internal state value type corresponding to this state value
	177	*/
	178	protected TmfXmlStateValueBase initializeStateValue(ITmfXmlModelFactory modelFactory, Element node) {
	179	return new TmfXmlStateValueNull();
	180	}
	181
	182	/**
	183	* Return the state system container this class is attached to
	184	*
	185	* @return The state system container
	186	*/
	187	protected IXmlStateSystemContainer getSsContainer() {
	188	return fContainer;
	189	}
	190
	191	/**
	192	* Get the state system associated with this value's container
	193	*
	194	* @return The state system associated with the state system container
	195	*/
12685851	196	protected @Nullable ITmfStateSystem getStateSystem() {
1d7e62f9 GB	197	return fContainer.getStateSystem();
	198	}
	199
	200	/**
	201	* Return whether this value is an increment of the previous value
	202	*
	203	* @return <code>true</code> if the value is an increment
	204	*/
	205	protected boolean isIncrement() {
	206	return fIncrement;
	207	}
	208
8ab1a965 GB	209	/**
	210	* Return whether this value should replace the current value of the
	211	* attribute or if a new state should be created.
	212	*
	213	* @return <code>true</code> if the value is to replace the current one
	214	*/
	215	protected boolean isUpdate() {
	216	return fUpdate;
	217	}
	218
1d7e62f9 GB	219	/**
	220	* Get the stack type of this attribute. If the attribute is to be pushed or
	221	* popped to a stack. The behavior of the stack attribute will depend on the
	222	* implementation of the model.
	223	*
	224	* @return The stack type of the attribute
	225	*/
	226	protected ValueTypeStack getStackType() {
	227	return fStackType;
	228	}
	229
	230	/**
	231	* Get the forced type of the value. For example, if the value obtained from
	232	* the attributes is not in this forced type, it will be converted to this.
	233	*
	234	* @return The desired type of the value
	235	*/
	236	protected ITmfStateValue.Type getForcedType() {
	237	return fForcedType;
	238	}
	239
1d7e62f9	240	@Override
0b563c20	241	public ITmfStateValue getValue(@Nullable ITmfEvent event, @Nullable TmfXmlScenarioInfo scenarioInfo) throws AttributeNotFoundException {
55df9717 JCK	242	return getMappedValue(event, scenarioInfo, fStateValue.getValue(event, scenarioInfo));
	243	}
	244
	245	private ITmfStateValue getMappedValue(@Nullable ITmfEvent event, @Nullable TmfXmlScenarioInfo scenarioInfo, ITmfStateValue value) {
	246	try {
	247	Set<TmfXmlMapEntry> group = null;
	248	if (fContainer instanceof XmlPatternStateProvider) {
	249	group = ((XmlPatternStateProvider) fContainer).getMappingGroup(fMappingGroup);
	250	} else if (fContainer instanceof XmlStateProvider) {
	251	group = ((XmlStateProvider) fContainer).getMappingGroup(fMappingGroup);
	252	}
	253	if (group != null) {
	254	for (TmfXmlMapEntry entry : group) {
	255	if (entry.getKey().getValue(event, scenarioInfo).equals(value)) {
	256	return entry.getValue().getValue(event, scenarioInfo);
	257	}
	258	}
	259	}
	260	return value;
	261	} catch (AttributeNotFoundException e) {
	262	Activator.logError("Unable to map the state value"); //$NON-NLS-1$
	263	// FIXME maybe we should return the raw state value instead of a
	264	// null state value
	265	return TmfStateValue.nullValue();
	266	}
1d7e62f9 GB	267	}
	268
	269	/**
	270	* Get the value of the event field that is the path of this state value
	271	*
	272	* @param event
	273	* The current event
	274	* @return the value of the event field
	275	*/
	276	@Override
	277	public ITmfStateValue getEventFieldValue(@NonNull ITmfEvent event) {
12685851 GB	278	String eventField = fEventField;
	279	if (eventField == null) {
	280	throw new IllegalStateException();
	281	}
	282	return getEventFieldValue(event, eventField);
1d7e62f9 GB	283	}
	284
	285	/**
	286	* Get the value of an event field
	287	*
	288	* @param event
	289	* The current event
	290	* @param fieldName
	291	* The name of the field of which to get the value
	292	* @return The value of the event field
	293	*/
12685851	294	protected ITmfStateValue getEventFieldValue(ITmfEvent event, String fieldName) {
1d7e62f9 GB	295
	296	ITmfStateValue value = TmfStateValue.nullValue();
	297
d6369798 GB	298	final ITmfEventField field = event.getContent().getField(fieldName);
	299
	300	/* If the field does not exist, see if it's a special case */
	301	if (field == null) {
	302
	303	if (fieldName.equalsIgnoreCase(TmfXmlStrings.CPU)) {
	304	/* A "CPU" field will return the CPU aspect if available */
	305	Integer cpu = TmfTraceUtils.resolveIntEventAspectOfClassForEvent(event.getTrace(), TmfCpuAspect.class, event);
	306	if (cpu != null) {
	307	return TmfStateValue.newValueInt(cpu.intValue());
	308	}
	309	} else if (fieldName.equalsIgnoreCase(TmfXmlStrings.TIMESTAMP)) {
	310	/*
	311	* Exception also for "TIMESTAMP", returns the timestamp of this
	312	* event
	313	*/
	314	return TmfStateValue.newValueLong(event.getTimestamp().getValue());
35f39420	315	}
1d7e62f9 GB	316	return value;
	317	}
	318
d6369798	319	Object fieldValue = field.getValue();
1d7e62f9 GB	320
	321	/*
	322	* Try to find the right type. The type can be forced by
	323	* "forcedType" argument.
	324	*/
	325
d6369798 GB	326	if (fieldValue instanceof String) {
d6369798 GB	327	String fieldString = (String) fieldValue;
1d7e62f9 GB	328
	329	switch (fForcedType) {
	330	case INTEGER:
	331	value = TmfStateValue.newValueInt(Integer.parseInt(fieldString));
	332	break;
	333	case LONG:
	334	value = TmfStateValue.newValueLong(Long.parseLong(fieldString));
	335	break;
	336	case DOUBLE:
	337	value = TmfStateValue.newValueDouble(Double.parseDouble(fieldString));
	338	break;
7ef85bff GB	339	case CUSTOM:
7ef85bff GB	340	throw new IllegalStateException("Custom type cannot be forced"); //$NON-NLS-1$
1d7e62f9 GB	341	case NULL:
	342	case STRING:
	343	default:
	344	value = TmfStateValue.newValueString(fieldString);
	345	break;
	346	}
d6369798 GB	347	} else if (fieldValue instanceof Long) {
d6369798 GB	348	Long fieldLong = (Long) fieldValue;
1d7e62f9 GB	349
	350	switch (fForcedType) {
	351	case INTEGER:
	352	value = TmfStateValue.newValueInt(fieldLong.intValue());
	353	break;
	354	case STRING:
	355	value = TmfStateValue.newValueString(fieldLong.toString());
	356	break;
	357	case DOUBLE:
	358	value = TmfStateValue.newValueDouble(fieldLong.doubleValue());
	359	break;
7ef85bff GB	360	case CUSTOM:
7ef85bff GB	361	throw new IllegalStateException("Custom type cannot be forced"); //$NON-NLS-1$
1d7e62f9 GB	362	case LONG:
	363	case NULL:
	364	default:
	365	value = TmfStateValue.newValueLong(fieldLong);
	366	break;
	367	}
d6369798 GB	368	} else if (fieldValue instanceof Integer) {
d6369798 GB	369	Integer fieldInteger = (Integer) fieldValue;
1d7e62f9 GB	370
	371	switch (fForcedType) {
	372	case LONG:
	373	value = TmfStateValue.newValueLong(fieldInteger.longValue());
	374	break;
	375	case STRING:
	376	value = TmfStateValue.newValueString(fieldInteger.toString());
	377	break;
	378	case DOUBLE:
	379	value = TmfStateValue.newValueDouble(fieldInteger.doubleValue());
	380	break;
7ef85bff GB	381	case CUSTOM:
7ef85bff GB	382	throw new IllegalStateException("Custom type cannot be forced"); //$NON-NLS-1$
1d7e62f9 GB	383	case INTEGER:
	384	case NULL:
	385	default:
	386	value = TmfStateValue.newValueInt(fieldInteger);
	387	break;
	388	}
d6369798 GB	389	} else if (fieldValue instanceof Double) {
d6369798 GB	390	Double fieldDouble = (Double) fieldValue;
1d7e62f9 GB	391
	392	switch (fForcedType) {
	393	case LONG:
	394	value = TmfStateValue.newValueLong(fieldDouble.longValue());
	395	break;
	396	case STRING:
	397	value = TmfStateValue.newValueString(fieldDouble.toString());
	398	break;
	399	case INTEGER:
	400	value = TmfStateValue.newValueInt(fieldDouble.intValue());
	401	break;
7ef85bff GB	402	case CUSTOM:
7ef85bff GB	403	throw new IllegalStateException("Custom type cannot be forced"); //$NON-NLS-1$
1d7e62f9 GB	404	case DOUBLE:
	405	case NULL:
	406	default:
	407	value = TmfStateValue.newValueDouble(fieldDouble);
	408	break;
	409	}
	410	}
	411	return value;
	412	}
	413
	414	/**
	415	* Get the list of state attributes, the path to the state value
	416	*
	417	* @return the list of Attribute to have the path in the State System
	418	*/
	419	@Override
	420	public List<ITmfXmlStateAttribute> getAttributes() {
	421	return fPath;
	422	}
	423
1d7e62f9	424	@Override
0b563c20	425	public void handleEvent(@NonNull ITmfEvent event, @Nullable TmfXmlScenarioInfo scenarioInfo) throws AttributeNotFoundException, StateValueTypeException, TimeRangeException {
1d7e62f9 GB	426	int quark = IXmlStateSystemContainer.ROOT_QUARK;
	427
	428	for (ITmfXmlStateAttribute attribute : fPath) {
0b563c20	429	quark = attribute.getAttributeQuark(event, quark, scenarioInfo);
1d7e62f9 GB	430	/* the query is not valid, we stop the state change */
1d7e62f9 GB	431	if (quark == IXmlStateSystemContainer.ERROR_QUARK) {
cf5a64e1 JCK	432	Activator.logError("Not found XML attribute " + attribute); //$NON-NLS-1$
cf5a64e1 JCK	433	return;
1d7e62f9 GB	434	}
	435	}
	436
	437	long ts = event.getTimestamp().getValue();
0b563c20	438	fStateValue.handleEvent(event, quark, ts, scenarioInfo);
1d7e62f9 GB	439	}
1d7e62f9 GB	440
446598f9 GB	441	@Override
446598f9 GB	442	public String toString() {
cbac1ac1 JCK	443	StringBuilder builder = new StringBuilder("TmfXmlStateValue: "); //$NON-NLS-1$
	444	if (fEventField != null) {
	445	builder.append("Field=").append(fEventField).append("; "); //$NON-NLS-1$ //$NON-NLS-2$
	446	} else if (!fPath.isEmpty()) {
	447	builder.append("Path=").append(fPath).append("; "); //$NON-NLS-1$ //$NON-NLS-2$
	448	}
	449	builder.append(fStateValue);
	450	return builder.toString();
446598f9 GB	451	}
446598f9 GB	452
1d7e62f9 GB	453	/**
	454	* Base class for all state values. Contain default methods to handle event,
	455	* process or increment the value
	456	*/
	457	protected abstract class TmfXmlStateValueBase {
	458
	459	/**
	460	* Get the value associated with this state value.
	461	*
	462	* @param event
	463	* The event which can be used to retrieve the value if
	464	* necessary. The event can be <code>null</code> if no event
	465	* is required.
0b563c20 JCK	466	* @param scenarioInfo
	467	* The active scenario details. The value should be null if
	468	* there no scenario.
1d7e62f9 GB	469	* @return The state value corresponding to this XML state value
	470	* @throws AttributeNotFoundException
	471	* Pass through the exception it received
	472	*/
0b563c20	473	public abstract ITmfStateValue getValue(@Nullable ITmfEvent event, @Nullable TmfXmlScenarioInfo scenarioInfo) throws AttributeNotFoundException;
1d7e62f9 GB	474
	475	/**
	476	* Do something with the state value, possibly using an event
	477	*
	478	* @param event
	479	* The event being handled. If there is no event is
	480	* available, use <code>null</code>.
	481	* @param quark
	482	* The quark for this value
	483	* @param timestamp
	484	* The timestamp of the event
0b563c20 JCK	485	* @param scenarioInfo
	486	* The active scenario details. The value should be null if
	487	* there no scenario.
1d7e62f9 GB	488	* @throws StateValueTypeException
	489	* Pass through the exception it received
	490	* @throws TimeRangeException
	491	* Pass through the exception it received
	492	* @throws AttributeNotFoundException
	493	* Pass through the exception it received
	494	*/
0b563c20	495	public void handleEvent(ITmfEvent event, int quark, long timestamp, @Nullable TmfXmlScenarioInfo scenarioInfo) throws StateValueTypeException, TimeRangeException, AttributeNotFoundException {
1d7e62f9	496	if (fIncrement) {
0b563c20	497	incrementValue(event, quark, timestamp, scenarioInfo);
1d7e62f9	498	} else {
0b563c20	499	ITmfStateValue value = getValue(event, scenarioInfo);
1d7e62f9 GB	500	processValue(quark, timestamp, value);
	501	}
	502	}
	503
	504	/**
	505	* Set the value of a quark at a given timestamp.
	506	*
	507	* @param quark
	508	* The quark for this value
	509	* @param timestamp
	510	* The timestamp
	511	* @param value
	512	* The value of this state value
	513	* @throws TimeRangeException
	514	* Pass through the exception it received
	515	* @throws StateValueTypeException
	516	* Pass through the exception it received
	517	* @throws AttributeNotFoundException
	518	* Pass through the exception it received
	519	*/
	520	@SuppressWarnings("unused")
	521	protected void processValue(int quark, long timestamp, ITmfStateValue value) throws TimeRangeException, StateValueTypeException, AttributeNotFoundException {
	522	}
	523
	524	/**
	525	* Increments the value of the parameter
	526	*
	527	* @param event
	528	* The event being handled
	529	* @param quark
	530	* The quark for this value
	531	* @param timestamp
	532	* The timestamp of the event
0b563c20 JCK	533	* @param scenarioInfo
	534	* The active scenario details. The value should be null if
	535	* there no scenario.
1d7e62f9 GB	536	* @throws StateValueTypeException
	537	* Pass through the exception it received
	538	* @throws TimeRangeException
	539	* Pass through the exception it received
	540	* @throws AttributeNotFoundException
	541	* Pass through the exception it received
	542	*/
	543	@SuppressWarnings("unused")
0b563c20	544	protected void incrementValue(ITmfEvent event, int quark, long timestamp, @Nullable TmfXmlScenarioInfo scenarioInfo) throws StateValueTypeException, TimeRangeException, AttributeNotFoundException {
1d7e62f9 GB	545	}
	546	}
	547
	548	/* This state value uses a constant value, defined in the XML */
	549	private class TmfXmlStateValueNull extends TmfXmlStateValueBase {
	550
	551	@Override
0b563c20	552	public ITmfStateValue getValue(@Nullable ITmfEvent event, @Nullable TmfXmlScenarioInfo scenarioInfo) throws AttributeNotFoundException {
1d7e62f9 GB	553	return TmfStateValue.nullValue();
	554	}
	555
cbac1ac1 JCK	556	@Override
	557	public String toString() {
	558	return "NULL"; //$NON-NLS-1$
	559	}
1d7e62f9 GB	560	}
1d7e62f9 GB	561
52293ccd	562	}