/ - Diff - Plateforme TXM - Forge du Centre Blaise Pascal

     	 * @param countTexts
     	 * @throws CqiClientException
     	 */
     	protected boolean _compute() {
     	protected boolean __compute() {
     		this.subTask("Computing balance with metadata propertyName = " + this.structuralUnitProperty + ", structural unit = " + this.structuralUnit.getName() + " and groupByTexts = " + this.countTexts); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
     		try {

     import org.txm.chartsengine.rcp.editors.ChartEditor;
     import org.txm.chartsengine.rcp.messages.SWTComponentsProviderMessages;
     import org.txm.core.messages.TXMCoreMessages;
     import org.txm.core.preferences.TXMPreferences;
     import org.txm.core.results.Parameter;
     import org.txm.core.results.TXMResult;
     import org.txm.progression.core.functions.Progression;
-...
     	/**
     	 * Queries.
     	 */
     	@Parameter(key=ProgressionPreferences.QUERIES)
     	protected List<Query> queryList;
     	@Parameter(key=TXMPreferences.QUERIES)
     	protected List<CQLQuery> queryList;
     	/**
     	 * Structural unit.
     	 */
     	@Parameter(key=ProgressionPreferences.STRUCTURAL_UNIT)
     	@Parameter(key=TXMPreferences.STRUCTURAL_UNIT)
     	protected StructuralUnitsComboViewer structuralUnitsComboViewer;
     	/**
     	 * Structural unit property.
     	 */
     	@Parameter(key=ProgressionPreferences.STRUCTURAL_UNIT_PROPERTY)
     	@Parameter(key=TXMPreferences.STRUCTURAL_UNIT_PROPERTY)
     	protected StructuralUnitPropertiesComboViewer structuralUnitPropertiesComboViewer;
     	/**
-...
     	@Override
     	public void updateEditorFromChart(boolean update) {
     		queryList = this.getResult().getQueries();
     		 // initialize query fields
     		if (queryWidgets.size() == 0 && queryList != null) {
     			for (Query q : queryList) {
-...
     	public void updateResultFromEditor() {
     		// create query list from widget
     		queryList = new ArrayList<Query>();
     		queryList = new ArrayList<CQLQuery>();
     		for (QueryField wid : queryWidgets) {
     			if (!wid.getQuery().isEmpty()) {
     				queryList.add(wid.getQuery());
     				queryList.add((CQLQuery) wid.getQuery());
     				wid.memorize();
+    			}
+    		}

     	@Override
     	protected boolean _compute() throws Exception {
     	protected boolean __compute() throws Exception {
     		// retrieve the parts
     		this.parts = this.getPartition().getParts();

     		return compute(monitor, true);
+    	}
     //	@Override
     //	public boolean compute(IProgressMonitor monitor, boolean deepComputing) {
     //
     //		if (this.computing) {
     //			return true;
     //		}
     //
     //		try {
     //			Log.finest("*** ChartResult.compute(): " + this.getClass().getSimpleName() + ": starting computing process...");
     //
     //			// compute the result if needed
     //			if(super.compute(monitor, deepComputing))	{
     //				this.altered = false;
     //				// compute the chart
     //				return renderChart();
     //			}
     //			else	{
     //				return false;
     //			}
     //		}
     //		catch (Exception e) {
     //			e.printStackTrace();
     //			Log.severe("ChartResult.compute(): Exception occurs during computing.");
     //			return false;
     //		}
     //	}
     	/**
     	 * This method is dedicated to be implemented by the inherited chart result classes to define the computing steps.
     	 * @return true if the result was computed
+    	 *
     	 * @throws Exception
     	 */
     	protected abstract boolean __compute() throws Exception;
     	@Override
     	public boolean compute(IProgressMonitor monitor, boolean deepComputing) {
     		if (computing) return true;
     	protected final boolean _compute()	{
     		boolean computingState = true;
     		try {
     			Log.finest("*** ChartResult.compute(): " + this.getClass().getSimpleName() + ": starting computing process...");
     			// compute the result if needed
     			if(super.compute(monitor, deepComputing))	{
     				this.altered = false;
     				// compute the chart
     				return renderChart();
+    			}
     			else	{
     				return false;
+    			}
     			Log.finest("*** ChartResult._compute(): " + this.getClass().getSimpleName() + ": starting computing process...");
     			// Computes the result only if at least one computing parameter has changed
     			//if(this.hasParameterChanged())	{
     				computingState = this.__compute();
     			//}
     			computingState = this.renderChart();
+    		}
     		catch (Exception e) {
     			e.printStackTrace();
     			Log.severe("ChartResult.compute(): Exception occurs during computing.");
     			return false;
     			Log.severe("ChartResult._compute(): Exception occurs during computing or rendering.");
     			computingState = false;
+    		}
     		return computingState;
+    	}
     	/**
-...
     		Log.finest("*** ChartResult.renderChart(): rendering chart for result " + this.getClass() + " and chart type " + this.getChartType() + "..."); //$NON-NLS-1$
     		// FIXME: SJ: need to clear the last computing parameters else we can't check if a computing parameter has changed in the chart creators
     //		if(this.parametersHistory.size() > 2
     //
     //				|| this.getLastParametersFromHistory().isEmpty()
     //				)	{
     //			this.clearLastComputingParameters();
     	//			)	{
     			//this.clearLastComputingParameters();
     //		}
     		// update the chart dirty state from history if a parameter has changed since last computing
     		this.updateChartDirtyFromHistory();
     		if (!this.chartDirty && !this.isChartDirtyFromHistory()) {
     		if (!this.chartDirty) {
     			Log.finest("--- ChartResult.renderChart(): chart rendering parameters have not changed since last rendering, rendering skipped."); //$NON-NLS-1$
     			return true;
+    		}
     		else if (!this.chartDirty) {
     			Log.finest("--- ChartResult.renderChart(): chart is not dirty, rendering skipped."); //$NON-NLS-1$
     			return true;
+    		}
     		ChartCreator chartCreator = this.getChartCreator();
     		// try to find a chart creator in other charts engines
-...
     			// Solution 1: store two stacks, one for computing parameters and another for rendering parameters
     			// Solution 2: stop to dissociate rendering parameters and computing parameters. Maybe the best way but need to check if this dissociation is very useless
     			// clear the last computing parameters
     			if(this.parametersHistory.size() > 2
     					//|| this.getLastParametersFromHistory().isEmpty()
     					)	{
     				this.clearLastComputingParameters();
+    			}
     //			if(this.parametersHistory.size() > 2
     //
     //					//|| this.getLastParametersFromHistory().isEmpty()
     //					)	{
     //				this.clearLastComputingParameters();
     //			}
     			// Creating, if needed.
     			// The change of the chart type parameter can occur if:
     			// - the chart has never been created
     			// - the chart type has been changed, e.g. to dynamically change the type of chart or the current charts engine
     			if (this.chart == null ||
     					//(this.getLastParametersFromHistory().get(ChartsEnginePreferences.CHART_TYPE) != null &&
     					this.hasParameterChanged(ChartsEnginePreferences.CHART_TYPE)
     					(this.getLastParametersFromHistory().get(ChartsEnginePreferences.CHART_TYPE) != null &&
     					this.hasParameterChanged(ChartsEnginePreferences.CHART_TYPE))
     					//)
     					) {
     				Log.finest("+++ ChartResult.renderChart(): creating chart."); //$NON-NLS-1$
     				Log.finest("+++ ChartResult.renderChart(): creating chart..."); //$NON-NLS-1$
     				this.chart = chartCreator.createChart(this);
+    			}
     			// Updating
     			Log.finest("ChartResult.renderChart(): updating chart.");
     			Log.finest("ChartResult.renderChart(): updating chart...");
     			// the update must be done here (BEFORE the call of this.updateLastRenderingParameters()) rather than in the SWTChartComponentsProvider => the problem is that for File based Engine, the file may be created twice, need to check this
     			// also before the call of this.updateLastParameters() to be able to check if a computing parameter has changed in the chart creators
-...
     			// FIXME: needed by the above fix #1
     			// reupdate the last computing parameters
     			this.updateLastParameters();
     			//this.updateLastParameters();
     			this.updateLastRenderingParameters();
     			//this.updateLastRenderingParameters();
     			this.needsToClearItemsSelection = false;
     			this.needsToResetView = false;
     			this.chartDirty = false;
     			// file persistence flush
     //			if (this.mustBePersisted()) {
     //				TXMPreferences.flush(this);
     //			}
     			// Debug
     			Log.finest("ChartResult.renderChart(): chart rendering done."); //$NON-NLS-1$
-...
+    	}
     	@Override
     	public boolean hasParameterChanged(String key) {
     		if (key.isEmpty()) {
     			return false;
+    		}
     		return super.hasParameterChanged(key);
+    	}
     //	@Override
     //	public boolean hasParameterChanged(String key) {
     //		if (key.isEmpty()) {
     //			return false;
     //		}
     //		return super.hasParameterChanged(key);
     //	}
     	@Override
     	public String dumpParameters() {
     		return super.dumpParameters() + "\n" + this.dumpParameters(Parameter.RENDERING); //$NON-NLS-1$
+    	}
     	/**
     	 * Updates the parameters used for last rendering.
+    	 *
     	 * @throws Exception
     	 */
     	protected void updateLastRenderingParameters() throws Exception {
     		this.updateLastParameters(Parameter.RENDERING, true);
+    	}
     //	/**
     //	 * Updates the parameters used for last rendering.
     //	 *
     //	 * @throws Exception
     //	 */
     //	protected void updateLastRenderingParameters() throws Exception {
     //		this.updateLastParameters(Parameter.RENDERING, true);
     //	}
     	/**
     	 * Clears the parameters used for last rendering.
-...
+    	}
     	/**
+    	 *
     	 * Checks if at least one rendering parameter value has changed since last computing.
     	 * @return
     	 * @throws Exception
     	 */
     	public final boolean isChartDirtyFromHistory() throws Exception {
     		List<Field> fields = this.getAllFields();
     		for (Field f : fields) {
     			Parameter parameter = f.getAnnotation(Parameter.class);
     			if (parameter == null || parameter.type() != Parameter.RENDERING) {
     				continue;
+    			}
     			String name;
     			if(!parameter.key().isEmpty())	{
     				name = parameter.key();
+    			}
     			else	{
     				name = f.getName();
+    			}
     			f.setAccessible(true); // not to set accessible to test the field values
     			// FIXME: old version
     			//Object previousValue = this.lastParameters.get(name);
     			// FIXME: new version with stack
     			Object previousValue = this.getLastParametersFromHistory().get(name);
     			Object newValue = f.get(this);
     			this.updateChartDirty(previousValue, newValue);
     			if (this.chartDirty) {
     				// FIXME: debug
     				Log.finest("ChartResult.isChartDirtyFromHistory(): parameter " + name + " has changed.");
     				return this.chartDirty; // no need to go further
+    			}
     	public boolean hasRenderingParameterChanged() throws Exception {
     		return this.hasParameterChanged(this.getLastParametersFromHistory(), Parameter.RENDERING);
+    	}
     	@Override
     	public void updateDirtyFromHistory() throws Exception {
     		this.dirty = super.hasParameterChanged();
     		if(!this.dirty)	{
     			this.dirty = this.hasRenderingParameterChanged();
+    		}
     		return this.chartDirty;
+    	}
     	/**
     	 * Updates the chart dirty state by comparing an old parameter with a new one.
+    	 *
     	 * @param lastValue may be null
     	 * @param newValue may be null
     	 * Sets the chart dirty state to true if a rendering parameter has changed since last computing.
     	 * @return
     	 * @throws Exception
     	 */
     	protected void updateChartDirty(Object lastValue, Object newValue) {
     		if(lastValue == null && newValue == null)	{
     			return;
+    		}
     		if (lastValue == null || !lastValue.equals(newValue)) {
     			Log.info("ChartResult.updateChartDirty(): " + this.getClass().getSimpleName() + ": setting chart dirty to true: last = "+ lastValue + " / new = " + newValue);
     	public void updateChartDirtyFromHistory() throws Exception {
     		if(this.hasRenderingParameterChanged())	{
     			this.chartDirty = true;
+    		}
+    	}
     //	/**
     //	 * Updates the chart dirty state by comparing an old parameter with a new one.
     //	 *
     //	 * @param lastValue may be null
     //	 * @param newValue may be null
     //	 */
     //	protected void updateChartDirty(Object lastValue, Object newValue) {
     //		if(lastValue == null && newValue == null)	{
     //			return;
     //		}
     //		if (lastValue == null || !lastValue.equals(newValue)) {
     //			Log.info("ChartResult.updateChartDirty(): " + this.getClass().getSimpleName() + ": setting chart dirty to true: last = "+ lastValue + " / new = " + newValue);
     //			this.chartDirty = true;
     //		}
     //	}
     	@Override
     	public ChartResult clone() {
     		ChartResult clone = null;
-...
     		clone.chart = null;
     		// FIXME: would be nice to clone the chart if possible instead of clearing the last rendering parameters?
     		//clone.chart = this.chart.clone();
     		clone.clearLastRenderingParameters(); // to force recreation of the chart at next computing
     		clone.clearLastRenderingParameters(); // to force recreation of the chart at next computing // FIXME: SJ: need to see if it's necessary, the chartDirty state may be sufficient
     		clone.chartDirty = true;
     		clone.hasBeenComputedOnce = false;
     		return clone;

+    	}
     	@Override
     	protected boolean _compute() throws Exception {
     	protected boolean __compute() throws Exception {
     		try {
     			// clear cache

     	@Override
     	protected boolean _compute() throws Exception {
     	protected boolean __compute() throws Exception {
     		// nothing to do
     		return true;
+    	}

     	@Override
     	protected boolean _compute() {
     	protected boolean __compute() {
     //		// FIXME: source must always be an Index because the corpus source produces an Index
     //		// from corpus
     //		if (source instanceof Corpus)	{

     	/**
     	 * Queries.
     	 */
     	@Parameter(key=TBXPreferences.QUERIES)
     	@Parameter(key=TXMPreferences.QUERIES)
     	protected List<CQLQuery> queries;
     	/**
     	 * Structural unit.
     	 */
     	@Parameter(key=TBXPreferences.STRUCTURAL_UNIT)
     	@Parameter(key=TXMPreferences.STRUCTURAL_UNIT, type=Parameter.RENDERING)
     	protected StructuralUnit structuralUnit;
     	/**
     	 * Structural unit property.
     	 */
     	@Parameter(key=TBXPreferences.STRUCTURAL_UNIT_PROPERTY)
     	@Parameter(key=TXMPreferences.STRUCTURAL_UNIT_PROPERTY, type=Parameter.RENDERING)
     	protected StructuralUnitProperty structuralUnitProperty;
     	/**
     	 * Repeats or not the same value when displaying the section markers.
     	 */
     	@Parameter(key=ProgressionPreferences.REPEAT_SAME_VALUES)
     	@Parameter(key=ProgressionPreferences.REPEAT_SAME_VALUES, type=Parameter.RENDERING)
     	protected boolean repeatValues;
     	/**
-...
     	/**
     	 * Regex to display only the property that match it.
     	 */
     	@Parameter(key=ProgressionPreferences.PROPERTY_REGEX)
     	@Parameter(key=ProgressionPreferences.PROPERTY_REGEX, type=Parameter.RENDERING)
     	protected String propertyRegex;
-...
     	 * @throws CqiServerError
     	 * @throws IOException
     	 */
     	protected boolean _compute() throws Exception {
     	protected boolean __compute() throws Exception {
     		// Queries
     		if(this.hasParameterChanged(ProgressionPreferences.QUERIES))	{

     //		System.err.println("*******************************JFCProgressionCumulativeChartCreator.updateChart(): has query parameter change = " + t1 + " / older = " + t2);
     		if(
     				progression.hasParameterChanged(TXMPreferences.QUERIES)
     				||
     				progression.hasParameterChanged(TXMPreferences.QUERIES, true)
     //				||
     //				progression.hasParameterChanged(TXMPreferences.QUERIES, true)
     				)	{
     			XYSeriesCollection dataset = (XYSeriesCollection) chart.getXYPlot().getDataset();
     			dataset.removeAllSeries();

     	 * @see org.txm.core.results.TXMResult#_compute()
     	 */
     	@Override
     	protected boolean _compute() throws Exception {
     	protected boolean __compute() throws Exception {
     		// TODO Auto-generated method stub
     		return true;
+    	}

     				else if(object instanceof NewNavigationWidget)	{
     					((NewNavigationWidget)object).setCurrentPosition((Integer) value);
+    				}
     				else if(object instanceof AssistedQueryWidget)	{
     					if(!((CQLQuery)value).getQueryString().isEmpty())	{
     						((AssistedQueryWidget)object).setText(((CQLQuery)value).getQueryString());
+    					}
+    				}
     				else if(object instanceof AssistedChoiceQueryWidget)	{
     					if(!((Query)value).getQueryString().isEmpty())	{
     						((AssistedChoiceQueryWidget)object).setText(((Query)value).getQueryString());

     			throw new IllegalArgumentException(NLS.bind(TXMUIMessages.theNumberOfEditorsP0AndNumberOfInputsP1MustBeEqual, editors.size(), inputs.size()));
+    		}
     		// put first editor in the left panel and set is as "main" editor
     		// put first editor in the left panel and set it as "main" editor
     		try {
     			final CAFactorialMapChartEditor caFactorialMapEditorPart = (CAFactorialMapChartEditor) editors.get(0);

     		super(parametersNodePath);
+    	}
     	@Override
     	protected boolean _compute() throws Exception {
     	protected boolean __compute() throws Exception {
     		Specificities specificities = this.getParent();
     		double[][] tableLines = specificities.getSpecificitesIndex();
     		String[] partNames = specificities.getColumnsNames();

     	 * Saves all preferences and session results in the default app directory.
     	 */
     	public static void saveAll() {
     		Log.info("Saving preferences and session results...");
     		Log.info("Saving preferences and session results.");
     		try {
     			preferencesRootNode.flush();
     		} catch(Exception e) {

     			Log.finest("Warning: the TXMResult of " + this.getClass() + " is attached to no parent. (uuid = " + this.parametersNodePath + ")"); //$NON-NLS-1$ //$NON-NLS-2$
+    		}
     		try {
     			this.parametersHistory.add(new HashMap<String, Object>());
     			//this.updateLastParameters();
+    		}
     		catch (Exception e) {
     			// TODO Auto-generated catch block
     			e.printStackTrace();
+    		}
     //		try {
     //			this.parametersHistory.add(new HashMap<String, Object>());
     //			//this.updateLastParameters();
     //		}
     //		catch (Exception e) {
     //			// TODO Auto-generated catch block
     //			e.printStackTrace();
     //		}
+    	}
     	/**
-...
+    	}
     	/**
     	 * Returns all the member fields of the class instance.
     	 * Returns all the member fields of the class instance (from all inherited classes).
     	 * @return the list of declared fields
     	 */
     	public List<Field> getAllFields()	{
-...
     	 * @param appendToLastParameters
     	 * @throws Exception
     	 */
     	// FIXME: SJ: should become useless after ChartResult changes
     	protected void updateLastParameters(int parameterType, boolean appendToLastParameters) throws Exception {
     		HashMap<String, Object> lastParameters;
-...
+    		}
     		// truncate the stack to the max count
     		// FIXME: store this in a TBX preference
     		// FIXME: SJ: later, store this in a TBX preference
     		if(this.parametersHistory.size() > 5)	{
     			this.parametersHistory.remove(0);
     			this.parametersHistory.remove(0);
-...
     	/**
+    	 *
     	 * Removes all the parameters of the specified type from the last parameters history.
     	 * @param parameterType
     	 * @throws Exception
     	 */
-...
+    	}
     	/**
     	 * Clears the parameters used for last computing.
     	 * Dedicated to force a full recomputing.
     	 * @throws Exception
     	 */
     	protected void clearLastComputingParameters() {
     		this.clearLastParameters(Parameter.COMPUTING);
+    	}
     //	/**
     //	 * Clears the parameters used for last computing.
     //	 * Dedicated to force a full recomputing.
     //	 * @throws Exception
     //	 */
     //	protected void clearLastParameters() {
     //		this.clearLastParameters(Parameter.COMPUTING);
     //	}
     	/**
-...
     	 * @param older
     	 * @return
     	 */
     	public boolean hasParameterChanged(String key, boolean older) {
     		if(older)	{
     			return this.hasParameterChanged(key, this.parametersHistory.get(this.parametersHistory.size() - 2));
+    		}
     		else	{
     			return this.hasParameterChanged(key);
+    		}
+    	}
     	// FIXME: SJ: should become useless after ChartResult changes
     //	@Deprecated
     //	public boolean hasParameterChanged(String key, boolean older) {
     //		if(older)	{
     //			return this.hasParameterChanged(key, this.parametersHistory.get(this.parametersHistory.size() - 2));
     //		}
     //		else	{
     //			return this.hasParameterChanged(key);
     //		}
     //	}
     	/**
     	 * Checks if a parameter value has changed since last computing.
-...
     	 * @return
     	 */
     	public boolean hasParameterChanged(String key, HashMap<String, Object> lastParameters) {
     		if(lastParameters == null)	{
     			return true;
+    		}
     		if (key.isEmpty()) {
     			return false;
+    		}
     		//		if (this.isDirty()) {
     		//			return true;
     		//		}
     		Object lastValue = lastParameters.get(key);
     		Object newValue = this.getParameter(key);
-...
+    		}
+    	}
     	/**
     	 * Checks if at least one parameter value of the specified parameter type has changed since last computing according to the specified external map.
     	 * @param lastParameters
     	 * @param parameterType
     	 * @return
     	 */
     	public boolean hasParameterChanged(HashMap<String, Object> lastParameters, int parameterType) throws Exception {
     		// result has never been computed
     		if(lastParameters == null)	{
     			return true;
+    		}
     		boolean hasParameterChanged = false;
     		List<Field> fields = this.getAllFields();
     		for (Field f : fields) {
     			Parameter parameter = f.getAnnotation(Parameter.class);
     			if (parameter == null || parameter.type() != parameterType) {
     				continue;
+    			}
     			String name;
     			if (!parameter.key().isEmpty())	{
     				name = parameter.key();
+    			}
     			else {
     				name = f.getName();
+    			}
     			f.setAccessible(true); // to be able to test the field values
     			hasParameterChanged = this.hasParameterChanged(name, lastParameters);
     			if (hasParameterChanged) {
     				Log.finest("TXMResult.hasParameterChanged(): " + this.getClass().getSimpleName() + ": parameter " + name + " has changed.");
     				break;
+    			}
+    		}
     		return hasParameterChanged;
+    	}
     	/**
     	 * Checks if at least one computing parameter value has changed since last computing.
     	 * @return
     	 * @throws Exception
     	 */
     	public boolean hasParameterChanged() throws Exception {
     		return this.hasParameterChanged(this.getLastParametersFromHistory(), Parameter.COMPUTING);
+    	}
     	/**
     	 * Dumps the command and default preferences of the result preferences node qualifier.
     	 * @return
     	 */
-...
     	/**
     	 * Updates the dirty state by comparing an old parameter with a new one.
+    	 *
     	 * @param lastValue may be null
     	 * @param newValue may be null
     	 */
     	protected void updateDirty(Object lastValue, Object newValue) {
     		if(lastValue == null && newValue == null)	{
     			return;
+    		}
     		if (lastValue == null || !lastValue.equals(newValue)) {
     			Log.info("TXMResult.updateDirty(): " + this.getClass().getSimpleName() + ": setting dirty to true: last = "+ lastValue + " / new = " + newValue);
     			this.setDirty();
+    		}
+    	}
     //	/**
     //	 * Updates the dirty state by comparing an old parameter with a new one.
     //	 *
     //	 * @param lastValue may be null
     //	 * @param newValue may be null
     //	 */
     //	protected void updateDirty(Object lastValue, Object newValue) {
     //		if(lastValue == null && newValue == null)	{
     //			return;
     //		}
     //		if (lastValue == null || !lastValue.equals(newValue)) {
     //			Log.info("TXMResult.updateDirty(): " + this.getClass().getSimpleName() + ": setting dirty to true: last = "+ lastValue + " / new = " + newValue);
     //			this.setDirty();
     //		}
     //	}
     	/**
     	 * Updates the dirty states by comparing TXMResult @Parameter with previously used parameters in the compute() method.
     	 * Sets the dirty state to true if a parameter has changed since last computing.
+    	 *
     	 * To work correctly :
     	 *  - the equals method of the TXMResult parameters must be correctly implemented.
     	 *  - the @Parameter member must be another variable (the previous is stored in the lastParameters protected variable) (e.g editing a List @Parameter is not enough for this test)
+    	 *
     	 * The method is final and don't need to be re-implemented. To ignore this method, don't use the @Parameter annotations
+    	 *
     	 * Implement isDirty if you need more test
+    	 *
     	 * @return
     	 * @throws IllegalAccessException
     	 * @throws IllegalArgumentException
     	 * @throws Exception
     	 */
     	public final boolean isDirtyFromHistory() throws Exception {
     		List<Field> fields = this.getAllFields();
     	public void updateDirtyFromHistory() throws Exception {
     //
     ////		// result has never been computed
     ////		if(this.getLastParametersFromHistory() == null)	{
     ////			this.dirty = true;
     ////			return true;
     ////		}
     ////
     ////		List<Field> fields = this.getAllFields();
     ////
     ////		for (Field f : fields) {
     ////			Parameter parameter = f.getAnnotation(Parameter.class);
     ////			if (parameter == null
     ////					|| parameter.type() == Parameter.INTERNAL
     ////					//|| parameter.type() != Parameter.COMPUTING
     ////					) {
     ////				continue;
     ////			}
     ////			String name;
     ////			if (!parameter.key().isEmpty())	{
     ////				name = parameter.key();
     ////			}
     ////			else {
     ////				name = f.getName();
     ////			}
     ////
     ////			f.setAccessible(true); // to be able to test the field values
     ////
     ////			Object previousValue = this.getLastParametersFromHistory().get(name);
     ////			Object newValue = f.get(this);
     ////
     ////			//			// FIXME: debug
     ////			//			Log.finest("TXMResult.isDirtyFromHistory(): checking parameter: " + name);
     ////
     ////			this.updateDirty(previousValue, newValue);
     ////			if (this.dirty) {
     ////				Log.finest("TXMResult.isDirtyFromHistory(): " + this.getClass().getSimpleName() + ": parameter " + name + " has changed.");
     ////				return this.dirty; // no need to go further
     ////			}
     ////		}
     ////		return this.dirty;
     //
     //		this.dirty = this.hasParameterChanged();
     ////		if (this.chartDirty) {
     ////			// FIXME: debug
     ////			Log.finest("ChartResult.isChartDirtyFromHistory(): parameter " + name + " has changed.");
     ////			return this.chartDirty; // no need to go further
     ////		}
     ////		return this.dirty;
     //		if(this.dirty)	{
     //			return true;
     //		}
     //		else	{
     			//return this.hasParameterChanged();
     //		}
     		for (Field f : fields) {
     			Parameter parameter = f.getAnnotation(Parameter.class);
     			if (parameter == null
     					|| parameter.type() != Parameter.COMPUTING
     					// FIXME: non electric mode tests
     					//|| parameter.electric() == false
     					) {
     				continue;
+    			}
     			String name;
     			if (!parameter.key().isEmpty())	{
     				name = parameter.key();
+    			}
     			else {
     				name = f.getName();
+    			}
     			f.setAccessible(true); // to be able to test the field values
     			Object previousValue = this.getLastParametersFromHistory().get(name);
     			Object newValue = f.get(this);
     			//			// FIXME: debug
     			//			Log.finest("TXMResult.isDirtyFromHistory(): checking parameter: " + name);
     			this.updateDirty(previousValue, newValue);
     			if (this.dirty) {
     				Log.finest("TXMResult.isDirtyFromHistory(): " + this.getClass().getSimpleName() + ": parameter " + name + " has changed.");
     				return this.dirty; // no need to go further
+    			}
     		if(this.hasParameterChanged())	{
     			this.dirty = true;
+    		}
     		return this.dirty;
+    	}
     	public HashMap<String, Object> getLastParametersFromHistory()	{
     		return this.parametersHistory.get(this.parametersHistory.size() - 1);
     		try {
     			return this.parametersHistory.get(this.parametersHistory.size() - 1);
+    		}
     		catch (Exception e) {
     			return null;
+    		}
+    	}
     	/**
-...
+    				}
+    			}
     			// check if the result is dirty (manually dirty or have some parameters changed since last computing)
     			boolean d1 = this.isDirtyFromHistory();
     			boolean d2 = this.isDirty();
     			if (!d1 && !d2) {
     			// update the dirty state from history if a parameter has changed since last computing
     			this.updateDirtyFromHistory();
     			// check if the result is dirty
     			if (!this.isDirty()) {
     				Log.finest("--- TXMResult.compute(): " + this.getClass().getSimpleName() + ": result parameters have not changed since last computing, computing skipped.");
     				skipComputing = true;
+    			}
-...
     					this.computing = false;
     					return false;
+    				}
     //				// clear the lazy name, no more needed since the object has been computed and getSimpleName() can now work
     //				this.lazyName = null;
     //
     //				// store last used parameters
     //				this.updateLastParameters();
+    			}
     			// clear the lazy name, no more needed since the object has been computed and getSimpleName() can now work
-...
     				// store last used parameters
     //				this.updateLastParameters();
     				if (this.hasBeenComputedOnce// don't update the compute date if the object has been lazy loaded
     				if (this.hasBeenComputedOnce// don't update the computing date if the object has been lazy loaded
     						|| this.lastComputingDate == null) { // set the update date if never computed once
     					this.lastComputingDate = Calendar.getInstance().getTime(); // update this internal parameter before saving parameters
+    				}
-...
+    	}
     	/**
+    	 *
     	 * This method is dedicated to be implemented by the inherited result classes to define the computing steps.
     	 * @return true if the result was computed
+    	 *
     	 * @throws Exception

+    	}
     	@Override
     	protected boolean _compute()	{
     	protected boolean __compute()	{
     		Log.info("Computing AHC...");
     		try {

Laboratoire ICAR » Plateforme TXM

Révision 1536