Laboratoire ICAR » Plateforme TXM

import java.io.IOException;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.nio.file.Path;

import java.text.DateFormat;

import java.text.SimpleDateFormat;

 * 

 */

public abstract class TXMResult implements Cloneable, Comparable<TXMResult> {

	public static final DateFormat ID_TIME_FORMAT = new SimpleDateFormat("yyyyMMdd_HHmmssSSS"); //$NON-NLS-1$

	public static final DateFormat PRETTY_TIME_FORMAT = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss"); //$NON-NLS-1$

	public static final DateFormat PRETTY_LOCALIZED_TIME_FORMAT = new SimpleDateFormat("dd MMMM yyyy, HH'h'mm", Locale.getDefault()); //$NON-NLS-1$

	public static final String UUID_PREFIX = "txm_res_"; //$NON-NLS-1$

	public static final Pattern FILE_NAME_PATTERN = Pattern.compile("[^a-zA-Z0-9\\.-_]+"); //$NON-NLS-1$

	public static final String UNDERSCORE = "_"; //$NON-NLS-1$

	/**

	 * Results counter to create unique ids.

	 */

	private static int next = 0;

	/**

	 * The weight, essentially used for sorting purpose.

	 */

	protected int weight;

	/**

	 * the command this command to true when the result needs to be recomputed.

	 * like after updating parameters

	 */

	private boolean dirty = true;

	/**

	 * If a method changed the internal data without **recomputing** the result, the result must be marked "altered"

	 */

	private boolean altered = false;

	/**

	 * The result parent. Should not be null except for roots TXMResult.

	 */

	protected TXMResult parent;

	/**

	 * Children results.

	 */

	protected List<TXMResult> children;

	/**

	 * Command preferences node path.

	 */

	protected String commandPreferencesNodePath;

	/**

	 * Parameters node path. Concatenation of the Project scope path + the result uuid

	 */

	private String parametersNodePath;

	/**

	 * Thread used when calling compute().

	 */

	protected Thread computingThread;

	/**

	 * To manage the computing cancel with TreadDeath.

	 */

	// FIXME: SJ: became useless? 

	private Semaphore progressSemaphore = new Semaphore(1);

	/**

	 * To keep track of the parameters used for the last computing and to determine if the result is dirty.

	 * Also permits to optimize computing by testing if a specific parameter value has changed since last computing and skip or not some computing steps.

	 */

	protected ArrayList<HashMap<String, Object>> parametersHistory = null;

	/**

	 * User persistable state.

	 */

	@Parameter(key = TXMPreferences.PERSITABLE, type = Parameter.INTERNAL)

	private boolean userPersistable;

	/**

	 * The visibility state.

	 */

	@Parameter(key = TXMPreferences.VISIBLE, type = Parameter.INTERNAL)

	private Boolean visible;

	/**

	 * The user name (to rename a result).

	 */

	@Parameter(key = TXMPreferences.USER_NAME, type = Parameter.INTERNAL)

	private String userName;

	/**

	 * To store the simple name for unserialization and lazy loading.

	 * This string can be used, for example, to display some information in UI even if the result has not yet been recomputed.

	// TODO: SJ: we should do the same with getDetails() method

	@Parameter(key = TXMPreferences.LAZY_NAME, type = Parameter.INTERNAL)

	private String lazyName;

	/**

	 * Last computing date.

	 */

	@Parameter(key = TXMPreferences.LAST_COMPUTING_DATE, type = Parameter.INTERNAL)

	private Date lastComputingDate;

	/**

	 * Creation date.

	 */

	@Parameter(key = TXMPreferences.CREATION_DATE, type = Parameter.INTERNAL)

	private Date creationDate;

	/**

	 * If locked, the result is not updated when computed.

	 */

	@Parameter(key = TXMPreferences.LOCK, type = Parameter.INTERNAL)

	private Boolean locked = false;

	/**

	 * Current computing state.

	 * True if the result is in the process of computing (is in compute(,) method)

	 */

	private boolean computing = false;

	/**

	 * Synchronization state between this result and its parent.

	 * If true, computing the parent will always also computes this child.

	 */

	protected boolean synchronizedWithParent = false;

	/**

	 * Creates a new TXMResult, child of the specified parent.

	 * 

	public TXMResult(TXMResult parent) {

		this(null, parent);

	}

	/**

	 * Creates a new TXMResult with no parent.

	 * If a local preference node exists with parent_parameters_node_path value, the parent will be retrieved and this result will be added to it.

	public TXMResult(String parametersNodePath) {

		this(parametersNodePath, null);

	}

	/**

	 * Creates a new TXMResult, child of the specified parent.

	 * If the parameters node path is null, a new path is generated from the project root path ending by a new generated UUID.

		if (parent != null) {

			parent.addChild(this);

		}

		// new result

		if (parametersNodePath == null) {

			if (this.getProject() != null) {

			else {

				parametersNodePath = ""; //$NON-NLS-1$

			}

			this.parametersNodePath = parametersNodePath + createUUID() + "_" + this.getClass().getSimpleName(); //$NON-NLS-1$ ;

		}

		// lazy result (persistence / import) or linked result ("send to" commands)

		else {

			this.parametersNodePath = parametersNodePath;

		}

		Log.finest("TXMResult.TXMResult(): parameters node path: " + this.parametersNodePath + "."); //$NON-NLS-1$ //$NON-NLS-2$

		this.weight = 0;

		this.children = new ArrayList<>(1);

		// this.children = Collections.synchronizedList(new ArrayList<TXMResult>()); // FIXME: SJ: can fix the concurrent exception if needed when accessing children from multiple threads

		this.commandPreferencesNodePath = FrameworkUtil.getBundle(getClass()).getSymbolicName();

		Log.finest("TXMResult.TXMResult(): command preferences node path: " + this.commandPreferencesNodePath + "."); //$NON-NLS-1$ //$NON-NLS-2$

		this.visible = true;

		this.dirty = true;

		// set result as persistent if AUTO_PERSISTENCE_ENABLED preference is activated

		if (TBXPreferences.getInstance().getBoolean(TBXPreferences.AUTO_PERSISTENCE_ENABLED)) {

			this.saveParameter(TXMPreferences.PERSITABLE, true);

		}

		// retrieving parent from UUID/node path

		String parentNodePath = this.getStringParameterValue(TXMPreferences.PARENT_PARAMETERS_NODE_PATH);

		// System.out.println("TXMResult.TXMResult(): parent UUID = " + parentUUID);

		if (!("ROOT".equals(this.parametersNodePath)) && //$NON-NLS-1$

				parent == null &&

				this.parametersNodePath != null &&

				!parentNodePath.isEmpty()) {

			Log.finest("Searching parent with UUID/node path " + parentNodePath + "..."); //$NON-NLS-1$ //$NON-NLS-2$

			TXMResult retrievedParent = null;

			if (this.getProject() != null) {

				retrievedParent = TXMResult.getResult(this.getProject(), parentNodePath); // works only if parent and child are in the same project (which should be).

					TBXPreferences.delete(this);

				}

				catch (Exception e) {

				}

				return;

			}

		}

		// loads parameters from local result node, current command preferences or default command preferences

		try {

			this.autoLoadParametersFromAnnotations(); // auto fill from Parameter annotations

			this.loadParameters(); // subclasses manual settings

			try {

				if (this.creationDate == null) {

					this.creationDate = Calendar.getInstance().getTime();

			Log.severe("Fail to load the " + parametersNodePath + " result: " + e); //$NON-NLS-1$ //$NON-NLS-2$

			Log.printStackTrace(e);

		}

		// Log

		if (this.parent == null) {

			Log.finest("Warning: the TXMResult of " + this.getClass() + " is attached to no parent. (uuid = " + this.parametersNodePath + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-1$

		}

	}

	/**

	 * Sets the user name.

	 * 

	public void setUserName(String name) {

		this.userName = name;

	}

	/**

	 * @return true if the internal data has been modified

	 */

	public boolean isAltered() {

		return altered;

	}

	/**

	 * Mark the result as altered -> modifications are lost after a re-compute

	 */

	public void setAltered() {

		this.altered = true;

	}

	/**

	 * Do something when project is closed

	 */

	public void onProjectClose() {

	}

	/**

	 * Do something when project is opened

	 */

	public void onProjectOpen() {

	}

	/**

	 * Locks/unlocks the result.

	 */

	public void setLocked(boolean state) {

		this.locked = state;

		if (this.locked && this.parent != null) {

			this.parent.setLocked(true);

		}

			}

		}

	}

	/**

	 * @return true if the result is locked

	 */

	public boolean isLocked() {

		return this.locked;

	}

	/**

	 * Creates an UUID dedicated to preferences/parameters storing and to persistence of a result.

	 * 

	public static String createUUID() {

		return UUID_PREFIX + ID_TIME_FORMAT.format(new Date(System.currentTimeMillis())) + "_" + nextInt();

	}

	/**

	 * 

	 * @return the next integer in the current session of TXM

	private static synchronized String nextInt() {

		return String.format("%04d", next++); //$NON-NLS-1$

	}

	/**

	 * Checks if the result has at least one child.

	 * 

	public boolean hasChildren() {

		return this.children.size() > 0;

	}

	/**

	 * Gets the preferences node path of the result linked command.

	 * 

	public String getCommandPreferencesNodePath() {

		return this.commandPreferencesNodePath;

	}

	public String[] getCommandPreferencesKeys() throws BackingStoreException {

		return TXMPreferences.getCommandScopeKeys(this.commandPreferencesNodePath);

	}

	public String[] getDefaultPreferencesKeys() throws BackingStoreException {

		return TXMPreferences.getDefaultScopeKeys(this.commandPreferencesNodePath);

	}

	/**

	 * Gets a current parameter specified by its annotation "key".

	 * 

	public Object getParameter(String key) {

		return getParameter(key, false);

	}

	/**

	 * Gets a current parameter specified by its annotation "key".

	 * 

		}

		return null;

	}

	/**

	 * Stores the parameters of the specified types used during last computing in the specified HashMap.

	 * 

	 * @throws Exception

	 */

	protected void updateLastParameters(ArrayList<Integer> parametersTypes, HashMap<String, Object> lastParameters) throws Exception {

		List<Field> fields = BeanParameters.getAllFields(this);

		for (Field f : fields) {

			Parameter parameter = f.getAnnotation(Parameter.class);

			if (parameter == null || !parametersTypes.contains(parameter.type())) {

				continue;

			}

			String name;

			if (!parameter.key().isEmpty()) {

				name = parameter.key();

			else {

				name = f.getName();

			}

			f.setAccessible(true);

			lastParameters.put(name, f.get(this));

		}

		// if (lastParameters.isEmpty()) {

		// System.out.println("TXMResult.updateLastParameters() empty");

		// }

		if (this.parametersHistory == null) { // 

			this.parametersHistory = new ArrayList<HashMap<String,Object>>();

		}

		this.parametersHistory.add(lastParameters);

		// truncate the stack to the max count

		// FIXME: SJ: later, store this in a TBX preference

		if (this.parametersHistory.size() > 5) {

			this.parametersHistory.remove(0);

		}

	}

	/**

	 * Stores the last parameters of the specified types used during last computing.

	 * 

	protected void updateLastParameters(ArrayList<Integer> parametersTypes) throws Exception {

		this.updateLastParameters(parametersTypes, new HashMap<>());

	}

	/**

	 * Stores the last parameters used during last computing.

	 * 

		parametersTypes.add(Parameter.COMPUTING);

		this.updateLastParameters(parametersTypes);

	}

	/**

	 * Removes all the parameters of the specified type from the last parameters history.

	 * 

	 * @throws Exception

	 */

	protected void clearLastParameters(int parameterType) {

		if (parametersHistory == null) return; // nothing to do

		List<Field> fields = BeanParameters.getAllFields(this);

		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);

			try {

				this.getLastParametersFromHistory().remove(name);

				// nothing to do if the stack is empty

			}

		}

		try {

			if (this.parametersHistory != null && !this.getLastParametersFromHistory().isEmpty()) {

				this.parametersHistory.remove(this.parametersHistory.size() - 1);

			// nothing to do if the stack is empty

		}

	}

	/**

	 * Checks if a parameter value has changed since last computing.

	 * 

	 * @return

	 */

	public boolean hasParameterChanged(String key) {

		if (parametersHistory == null) return true;

		return this.hasParameterChanged(key, this.getLastParametersFromHistory());

	}

	/**

	 * Checks if a parameter value has changed since last computing according to the specified external map.

	 * 

	 * @return

	 */

	public boolean hasParameterChanged(String key, HashMap<String, Object> lastParameters) {

		if (lastParameters == null) {

			return true;

		}

		if (key.isEmpty()) {

			return false;

		}

		Object lastValue = lastParameters.get(key);

		Object newValue = this.getParameter(key, true);

		if (lastValue == null) {

			return !lastValue.equals(newValue);

		}

	}

	/**

	 * Checks if at least one parameter value of the specified parameter type has changed since last computing according to the specified external map.

	 * 

	 * @return

	 */

	public boolean hasParametersChanged(HashMap<String, Object> lastParameters, int parameterType) throws Exception {

		// result has never been computed

		if (lastParameters == null) {

			return true;

		}

		boolean hasParameterChanged = false;

		List<Field> fields = BeanParameters.getAllFields(this);

		for (Field f : fields) {

			Parameter parameter = f.getAnnotation(Parameter.class);

			if (parameter == null || parameter.type() != parameterType) {

			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 (type = " + parameterType + ").");

				break;

			}

		}

		return hasParameterChanged;

	}

	/**

	 * Checks if at least one computing parameter value has changed since last computing.

	 * 

	 */

	public boolean hasParametersChanged() throws Exception {

		if (parametersHistory == null) return true;

		return this.hasParametersChanged(this.getLastParametersFromHistory(), Parameter.COMPUTING);

	}

	/**

	 * Dumps the result current parameters, the command user preferences and the command default preferences linked to the result.

	 * 

	 * @return

	 */

	public String dumpPreferences() {

		StringBuilder str = new StringBuilder();

		if (TXMPreferences.resultScopeNodeExists(this)) {

			str.append("\nResult local node preferences\n"); //$NON-NLS-1$

			str.append(TXMPreferences.getKeysAndValues(this.getParametersNodePath()));

		}

		str.append("\nCommand preferences\n"); //$NON-NLS-1$

		str.append(TXMPreferences.getKeysAndValues(this.commandPreferencesNodePath));

		str.append("\nDefault command preferences\n"); //$NON-NLS-1$

		str.append(TXMPreferences.getKeysAndValues(DefaultScope.INSTANCE + "/" + this.commandPreferencesNodePath));

		return str.toString();

	}

	/**

	 * Dumps the result computing parameters (Parameter annotation).

	 * 

	public String dumpParameters() {

		return this.dumpParameters(Parameter.COMPUTING);

	}

	/**

	 * Dumps the result computing parameters (Parameter annotation).

	 * 

	 * @return

	 */

	public String dumpParameters(int parametersType) {

		StringBuilder str = new StringBuilder();

		str.append("Parameters (type = " + parametersType + " / " + Parameter.types[parametersType] + ")\n"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

		List<Field> fields = BeanParameters.getAllFields(this);

		for (Field f : fields) {

			Parameter parameter = f.getAnnotation(Parameter.class);

			if (parameter == null || parameter.type() != parametersType) {

				continue;

			}

			f.setAccessible(true);

			String name;

			if (!parameter.key().isEmpty()) {

				name = parameter.key();

			else {

				name = f.getName();

			}

			try {

				Object v = f.get(this);

				if (v != null) {

		}

		return str.toString();

	}

	// /**

	// * Updates the dirty state by comparing an old parameter with a new one.

	// *

	// this.setDirty();

	// }

	// }

	/**

	 * Sets the dirty state to true if a parameter has changed since last computing.

	 * 

		// else {

		// return this.hasParameterChanged();

		// }

		if (this.hasParametersChanged()) {

			this.dirty = true;

		}

	}

	/**

	 * Gets the list of parameters used during last computing or null if the result has not been computed yet.

	 * 

			return null;

		}

	}

	/**

	 * TODO seems to work but the TXMEditor.compute() method re-use the widgets values and the parametersHistory is appended with the 'new' parameters

	 * 

	public void revertParametersFromHistory() throws Exception {

		ArrayList<HashMap<String, Object>> history = getParametersHistory();

		if (history == null) return; // nothing to do

		if (history.size() < 2) return; // nothing to do

		history.remove(history.size() - 1);

		HashMap<String, Object> last = history.get(history.size() - 1);

		this.setParameters(last); // auto

	}

	/**

	 * Dumps the parameters history stack to the specified StringBuffer.

	 * 

			}

		}

	}

	/**

	 * Gets the dirty state.

	 * 

	public boolean isDirty() {

		return this.dirty;

	}

	/**

	 * Marks the result as dirty so editors or others will know the TXMResult needs to be recomputed.

	 * This method is also recursively called on all the children branch to mark them as dirty.

	public void setDirty() {

		this.setDirty(true);

	}

	/**

	 * Sets the result dirty state so editors or others will know the TXMResult needs to be recomputed or not.

	 * This method is also recursively called on all the children branch sets the new dirty state.

			}

		}

	}

	/**

	 * Gets the value of the specified key in parameters, local result node or

	 * default preferences nodes.

	public int getIntParameterValue(String key) {

		return TXMPreferences.getInt(key, this, this.commandPreferencesNodePath);

	}

	/**

	 * Gets the value of the specified key in parameters, local result node or

	 * default preferences nodes.

	public float getFloatParameterValue(String key) {

		return TXMPreferences.getFloat(key, this, this.commandPreferencesNodePath);

	}

	/**

	 * Gets the value of the specified key in parameters, local result node or

	 * default preferences nodes.

	public double getDoubleParameterValue(String key) {

		return TXMPreferences.getDouble(key, this, this.commandPreferencesNodePath);

	}

	/**

	 * Gets the value of the specified key in parameters, local result node or

	 * default preferences nodes.

	public boolean getBooleanParameterValue(String key) {

		return TXMPreferences.getBoolean(key, this, this.commandPreferencesNodePath);

	}

	/**

	 * Gets the value of the specified key in parameters, local result node or

	 * default preferences nodes.

	public long getLongParameterValue(String key) {

		return TXMPreferences.getLong(key, this, this.commandPreferencesNodePath);

	}

	/**

	 * Gets the value of the specified key in parameters, local result node or

	 * default preferences nodes.

	public String getStringParameterValue(String key) {

		return TXMPreferences.getString(key, this, this.commandPreferencesNodePath);

	}

	/**

	 * Gets the value of the specified key in parameters, local result node or

	 * default preferences nodes.

	public Date getDateParameterValue(String key) {

		return TXMPreferences.getDate(key, this, this.commandPreferencesNodePath);

	}

	/**

	 * Gets the value of the specified key in parameters, local result node or

	 * default preferences nodes.

			return null;

		}

	}

	/**

	 * Checks if the specified parameter exists.

	 * 

	public boolean parameterExists(String key) {

		return TXMPreferences.keyExists(this.parametersNodePath, key);

	}

	/**

	 * Checks if a preference is empty (equals to "") in the command preference node.

	 * An empty preference can be used to disable a functionality for a kind of result

	public boolean isEmptyPreference(String key) {

		return TXMPreferences.isEmpty(this.commandPreferencesNodePath, key);

	}

	/**

	 * Stores the specified parameters pairs of key/value in a local node dedicated to the specified result. The node qualifier is generated by the <code>TXMResult.getUUID</code> method.

	 * 

	public void saveParameter(String key, List<?> values) {

		this.saveParameter(key, StringUtils.join(values, UNDERSCORE));

	}

	/**

	 * Stores the specified parameters pairs of key/value in a local node dedicated to the specified result. The node qualifier is generated by the <code>TXMResult.getUUID</code> method.

	 * 

	public void saveParameter(String key, Object value) {

		// FIXME: debug

		// Log.info("TXMResult.saveParameter(): saving parameter " + key + " = " + value + " for " + this.getClass() + " (" + value.getClass() + ") to node.");

		TXMPreferences.putLocal(this, key, value);

	}

	/**

	 * Stores the result parameter fields declared by their @Parameter annotation in the persisted result node preferences.

	 * One have to implement saveParameters() to save parameters that are not of primitive types (e.g. Property, List, HashMap...)

	 * @throws Exception

	 */

	public boolean autoSaveParametersFromAnnotations() throws Exception {

		Log.finest("TXMResult.autoSaveParametersFromAnnotations(): " + this.getClass().getSimpleName() + ": saving parameters to local node...");

		// internal data to save for unserialization

		if (this.getClass().isAnonymousClass()) {

			this.saveParameter(TXMPreferences.CLASS, this.getClass().getSuperclass().getName()); // avoid bug later if an anonymous class has been used.

		}

		this.saveParameter(TXMPreferences.RESULT_PARAMETERS_NODE_PATH, this.parametersNodePath);

		this.saveParameter(TXMPreferences.BUNDLE_ID, FrameworkUtil.getBundle(getClass()).getSymbolicName());

		if (this.parent != null) {

			this.saveParameter(TXMPreferences.PARENT_PARAMETERS_NODE_PATH, this.parent.getParametersNodePath());

		}

		if (hasBeenComputedOnce()) {

			this.lazyName = this.getSimpleName();

		}

		List<Field> fields = BeanParameters.getAllFields(this);

		for (Field f : fields) {

			Parameter parameter = f.getAnnotation(Parameter.class);

			if (parameter == null) {

			if (key.isEmpty()) {

				continue; // no preference key defined

			}

			if (f.getType().isAssignableFrom(int.class) || f.getType().isAssignableFrom(Integer.class) ||

					f.getType().isAssignableFrom(double.class) || f.getType().isAssignableFrom(Double.class) ||

					f.getType().isAssignableFrom(float.class) || f.getType().isAssignableFrom(Float.class) ||

					f.getType().isAssignableFrom(boolean.class) || f.getType().isAssignableFrom(Boolean.class) ||

					f.getType().isAssignableFrom(String.class) || f.getType().isAssignableFrom(File.class)

				f.setAccessible(true); // set accessible to test the field values

				try {

					Object value = f.get(this);

		}

		return true;

	}

	/**

	 * Dedicated to stores the result parameters in the persisted result node preferences.

	 * One have to implement this method to save parameters that are not of primitive types (e.g. Property, List, HashMap...)

	 * @throws Exception

	 */

	public abstract boolean saveParameters() throws Exception;

	/**

	 * calls saveParameters() on this and children if childrenAsWell is set to true

	 * 

	 * @throws Exception

	 */

	public boolean saveParameters(boolean childrenAsWell) throws Exception {

		boolean ret = true;

		if (this.mustBePersisted()) {

			ret = this.saveParameters();

			if (childrenAsWell) {

		}

		return ret;

	}

	// FIXME: SJ: this method should not call persist on children if childrenAsWell == false?

	public void persist(boolean childrenAsWell) {

		if (this.mustBePersisted()) {

			}

		}

	}

	/**

	 *  load or reload parameters from the preference store node

	 * @return

	public boolean autoLoadParametersFromAnnotations() throws Exception {

		return this.autoLoadParametersFromAnnotations(Parameter.COMPUTING) && this.autoLoadParametersFromAnnotations(Parameter.INTERNAL);

	}

	/**

	 * Fills the result parameter fields declared by their @Parameter annotation from the persisted result node or default node of the preferences.

	 * One have to implement loadParameters() to load parameters that are not of primitive types (e.g. Property, List, HashMap...)

	 * @throws Exception

	 */

	protected boolean autoLoadParametersFromAnnotations(int parameterType) throws Exception {

		List<Field> fields = BeanParameters.getAllFields(this);

		for (Field f : fields) {

			Parameter parameter = f.getAnnotation(Parameter.class);

			if (parameter == null || parameter.type() != parameterType) {

				continue;

			}

			String key = parameter.key();

			if (key.isEmpty()) {

				continue; // no preference key defined for the parameter so it can't be filled with default value or result persistence value from preferences nodes

			}

			try {

				f.setAccessible(true); // set accessible to test the field values

				Object value = null;

				// only manage primitive types

				if (f.getType().isAssignableFrom(String.class)) {

					value = this.getStringParameterValue(key);

				// SJ: or better, when the abstraction of Property, etc. will be done, we could implement some extensions as in ChartCreator model to other engines, eg. SearchEngine, that will return

				// the right class here

				f.set(this, value);

				// FIXME: Debug

				Log.finest("TXMResult.autoLoadParametersFromAnnotations(): setting parameter " + key + " = " + value + "\t[" + this.getClass() + "]");

			}

			catch (Exception e) {

				e.printStackTrace();

		}

		return true;

	}

	/**

	 * Method dedicated to manually create and load non primitive parameters from strings stored in preference nodes in subclasses.

	 * This method is called by the constructor of the class TXMResult.

	 * @throws Exception

	 */

	public abstract boolean loadParameters() throws Exception;

	/**

	 * Initializes the @Parameter class members objects

	 * 

	 * @return

	 */

	public abstract boolean setParameters(TXMParameters parameters) throws Exception;

	/**

	 * Initializes the @Parameter class members objects

	 * 

	public final boolean setParameters(HashMap<String, Object> parameters) throws Exception {

		return setParameters(new TXMParameters(parameters));

	}

	/**

	 * Sets a parameter from its parameter annotation "key".

	 * 

	public boolean setParameter(String key, Object value) throws Exception {

		return setParameter(key, value, false);

	}

	/**

	 * Sets a parameter from its parameter annotation "key".

	 * 

	 * @throws Exception

	 */

	public boolean setParameter(String key, Object value, boolean propagateToParent) throws Exception {

		Field targetField = BeanParameters.getField(this, key);

		if (targetField != null) {

			targetField.setAccessible(true);

			targetField.set(this, value);

			// Log

			String message = "TXMResult.setParameter(): " + this.getClass().getSimpleName() + ": setting parameter " + key + " = " + value; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

			Log.finest(message);

		}

		else if (this.parent != null && propagateToParent) {

			this.parent.setParameter(key, value, propagateToParent);

		}

		return true;

	}

	/**

	 * Deletes the object from its parent, also deletes the children. The <code>TXMResult.clean()</code> methods of this result and children results are applied before the deletion.

	 * default behavior is not silent

	public final boolean delete() {

		return delete(false);

	}

	/**

	 * Deletes the object from its parent, also deletes the children. The <code>TXMResult.clean()</code> methods of this result and children results are applied before the deletion.

	 * 

	 * @return

	 */

	public final boolean delete(boolean silent) {

		try {

			// FIXME: debug

			// System.err.println("TXMResult.delete()");

			// START WITH CHILDREN

			// remove children and clean resources

			while (this.children.size() > 0) {

				TXMResult c = this.children.get(0);

				this.children.remove(c); // but should be done already...

			}

			this.children.clear();

			// THEN FINISH WITH THIS

			// delete the local node

			TXMPreferences.delete(this);

			// specific cleaning

			this.clean();

			// log

				Log.info(TXMCoreMessages.bind(TXMCoreMessages.info_p0P1Deleted, this.getResultType(), this.getSimpleName()));

			}

			// removes the parent only after the log since getSimpleName() can use it

			if (this.parent != null) {

				this.parent.removeChild(this);

			}

			return true;

		}

		catch (Exception e) {

			e.printStackTrace();

		}

		return false;

	}

	/**

	 * Deletes all non persistent results and saves the results to persist.

	 */

			}

		}

	}

	/**

	 * Gets a child specified by its index in the children list.

	 * 

			return null;

		}

	}

	/**

	 * Adds a child result to this result.

	 * If the child already have a parent, the child will be remove from its old parent children.

		try {

			// remove from current parent if exists

			child.removeFromParent();

			child.setParent(this);

			if (!this.children.contains(child)) {

				return this.children.add(child);

		}

		return false;

	}

	/**

	 * Inserts a child result in this result children list at the specified position.

	 * 

		}

		return false;

	}

	/**

	 * Removes the specified child result.

	 * 

		}

		return false;

	}

	/**

	 * Removes the child result specified by its index.

	 * 

			return this.removeChild(this.children.get(index));

		}

		catch (Exception e) {

		}

		return false;

	}

	/**

	 * Removes the result from its parent: call the parent's removeResult method.

	 * 

			return this.parent.removeChild(this);

		}

		catch (Exception e) {

		}

		return false;

	}

	/**

	 * Checks if the result has at least one child visible.

	 * 

	public boolean hasVisibleChild() {

		return !this.getChildren(true).isEmpty();

	}

	/**

	 * Gets all the children results (not a clone).

	 * 

	public List<TXMResult> getChildren() {

		return this.children;

	}

	/**

	 * Gets the children results.

	 * 

	public List<TXMResult> getChildren(boolean onlyVisible) {

		return this.getChildren(null, onlyVisible);

	}

	/**

	 * Gets the children results specified by their class.

	 * 

	public <T extends TXMResult> List<T> getChildren(Class<T> clazz) {

		return TXMResult.getNodes(this.children, clazz, false);

	}

	/**

	 * Gets the children results specified by their class.

	 * 

	public <T extends TXMResult> List<T> getChildren(Class<T> clazz, boolean onlyVisible) {

		return TXMResult.getNodes(this.children, clazz, onlyVisible);

	}

	/**

	 * Gets the first child result specified by its class.

	 * 

			return null;

		}

	}

	/**

	 * Deletes all the children

	 * 

	public void deleteChildren() {

		deleteChildren(null);

	}

	/**

	 * Deletes the children of the specified class.

	 * 

			children.get(i).delete();

		}

	}

	/**

	 * Gets the children of all the branch of the specified node in a flat list according to their specified class.

	 * 

	 */

	@SuppressWarnings("unchecked")

	protected static <T extends TXMResult> List<T> getDeepChildren(TXMResult parent, Class<T> clazz) {

		List<T> results = new ArrayList<>();

		List<TXMResult> children = parent.getChildren();

		for (int i = 0; i < children.size(); i++) {

			TXMResult child = children.get(i);

			if (clazz == null || child.getClass().isAssignableFrom(clazz)) {

		}

		return results;

	}

	/**

	 * Gets the children of all the branch in a flat list.

	 * 

	public <T extends TXMResult> List<T> getDeepChildren(Class<T> clazz) {

		return TXMResult.getDeepChildren(this, clazz);

	}

	/**

	 * Gets the children of all the branch in a flat list.

	 * 

	public static List<TXMResult> getDeepChildren(TXMResult result) {

		return TXMResult.getDeepChildren(result, null);

	}

	/**

	 * Gets the children of all the branch in a flat list.

	 * 

	public List<TXMResult> getDeepChildren() {

		return TXMResult.getDeepChildren(this);

	}

	/**

	 * Gets the TXMResult specified by its node path (UUID) in the children of the specified root result.

	 * Returns the root itself if the specified node path is equal to the root node path.

	 * @return