Laboratoire ICAR » Plateforme TXM

import java.io.File;

import java.util.ArrayList;

import org.txm.utils.DeleteDir;

public class Compiler extends ImportStep {

	protected File cqpDirectory, registryDirectory, dataDirectory;

	/**

	 * Creates the output directories

		process(null); // no default files order set

	}

	}

}

import java.io.File;

import java.util.ArrayList;

import org.txm.utils.DeleteDir;

	protected File htmlDirectory;

	protected String corpusname;

	public Pager(ImportModule module, String editionName) {

		super(module);

		process(null); // no default files order set

	}

	}

}

package org.txm.importer.xtz;

import java.io.File;

import java.util.logging.Level;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.txm.objects.Project;

import org.txm.utils.DeleteDir;

import org.txm.utils.LogMonitor;

import org.txm.utils.logger.Log;

public class ImportModule {

	public Project project;

	public String corpusVersionProduced;

	public File sourceDirectory;

	public String corpusName;

	IProgressMonitor monitor;

	public void setMonitor(IProgressMonitor monitor) {

		this.monitor = monitor;

	}

	public boolean isMultiThread() {

		return multithread;

	}

	public ImportModule(Project p) {

		init(p);

	}

	public boolean isUpdatingCorpus() {

		return updateCorpus;

	}

	public void init(Project p) {

		this.project = p;

		corpusName = project.getName();

		//this.debug = "true".equals(project.getKeyValueParameters().get(ImportKeys.DEBUG));

		if (Log.getLevel().intValue() < Level.INFO.intValue()) {

			debug = true;

		}

		this.multithread = project.getDoMultiThread();

		this.updateCorpus = project.getDoUpdate();

		this.sourceDirectory = project.getSrcdir();

		this.binaryDirectory = project.getProjectDirectory();

		if (!updateCorpus) { // clean directories only if it's a new import	

			File txmDir = new File(binaryDirectory, "txm");

			//DeleteDir.deleteDirectory(binaryDirectory);

				p.getRCPProject().getFolder("registry").delete(true, new LogMonitor("XTZ delete project content"));

				p.getRCPProject().getFolder("tokenized").delete(true, new LogMonitor("XTZ delete project content"));

				p.getRCPProject().getFolder("txm").delete(true, new LogMonitor("XTZ delete project content"));

			} catch (CoreException e) {

				e.printStackTrace();

			}

			txmDir.mkdirs();

			//System.out.println("ImportModule.start: not updating");

			if (importer != null) {

				//System.out.println("ImportModule.start: importer: "+importer);

				importer.process();

				//importer.checkFiles();

				isSuccessful = isSuccessful & importer.isSuccessFul();

				System.out.println("XML-TXM files already produced in "+new File(binaryDirectory, "txm/"+corpusName));

			}

			boolean annotate = project.getAnnotate();

			if (annotate && annotater != null) {

				annotater.process();

				isSuccessful = isSuccessful & annotater.isSuccessFul();

				if (!isSuccessful) {

			}

		} else {

			System.out.println("Updating corpus...");

		}

		//System.out.println("GET FILES ORDER");

			public void run() {

				if (compiler != null) {

					isSuccessful = isSuccessful & compiler.isSuccessFul();

					if (!isSuccessful) {

						System.out.println("Error while importing corpus during 'compiler' step, reason="+compiler.getReason());

				}

			}

		};

			public void run() {

				if (pager != null) {

					isSuccessful = isSuccessful & pager.isSuccessFul();

					if (!isSuccessful) {

						System.out.println("Error while importing corpus during 'pager' step, reason="+pager.getReason());

		};

		Tcompiler.start();

			Tcompiler.join(); // wait for the end if not multithreaded

			if (!isSuccessful) { // don't call pager is compiler step failed

				return;

			}

		}

		Tpager.start();

		if (multithread) Tcompiler.join(); // wait for both thread to end

			}

	}

	public void end() {

		File paramFile = new File(binaryDirectory, "import.xml");

		try {

			isSuccessful = false;

		}

	}

	public String getCorpusName() {

		return corpusName;

	}

	public File getBinaryDirectory() {

		return binaryDirectory;

	}

	public void process() throws InterruptedException {

		start();

		if (isSuccessful)

	}

	public static void main(String[] args) {

	}

}

import java.util.logging.Level;

import org.apache.commons.lang.StringUtils;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IConfigurationElement;

import org.eclipse.core.runtime.IProgressMonitor;

		// loads and recreate the existing projects, loadParameters() needs engines to be ready

		if (workspace != null) {

		} else {

			System.out.println("Error: Toolbox not correctly initialized. Aborting workspace initialization.");

		}

			//				TXMPreferences.deleteAllResultsNodes();

			//			}

			// FIXME: other tmp solution

			// save projects parameters

			if (Toolbox.workspace != null) {

				Toolbox.workspace.saveParameters(true);

			}

			Toolbox.workspace = null;

		}

		println "PROPERTIES"

		println " pattributes $pattributes"

		println " sattributes $sattributes"

errorWhilePreInstallingPluginsP0=Error while pre-installing plugins: {0}

loadingExtensionPostInstallation=Loading plug-in post-installation extensions...

errorWhilePostInstallingPluginsP0=Error while post-installing plugins: {0}

errorWhilePreInstallingPluginsP0=Erreur lors du pre-chargement des extensions : {0}

loadingExtensionPostInstallation=Post-chargement des extensions...

errorWhilePostInstallingPluginsP0=Erreur lors du post-chargement des extensions : {0}

import org.eclipse.core.resources.IProject;

import org.eclipse.core.resources.IProjectNature;

import org.eclipse.core.runtime.CoreException;

public class CorpusNature implements IProjectNature {

	public static final String NATURE_ID = "org.txm.core.CorpusNature";

	/**

	/**

	 * print TxmPreferences in the console.

	 */

	public static void dump() {

		try {

			System.out.println("root:"); //$NON-NLS-1$

		else if (Boolean.class.isInstance(value))	{

			preferencesRootNode.node(nodePath).putBoolean(key, (Boolean) value);

		}

		else if (Serializable.class.isInstance(value))	{

			try {

				preferencesRootNode.node(nodePath).put(key, toString((Serializable)value));

	 * Results counter to create unique ids.

	 */

	private static int next = 0;

	/**

	 * Editor can use this to test if the result has been computed once.

	 */

	 * like after updating parameters

	 */

	protected boolean dirty = true;

	/**

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

	 */

	 * 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 = new ArrayList<HashMap<String, Object>>();

	/**

	 * Internal persistable state.

	 */

	 */

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

	/**

	 * Current computing state.

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

		}

		// no parametersNodePath -> new result

		if (parametersNodePath == null)	{ // new object

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

				parametersNodePath = this.getProject().getParametersNodeRootPath();

			else {

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

			}

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

		}

		else	{

				parent == null && 

				this.parametersNodePath != null && 

				!parentNodePath.isEmpty()) {

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

			//TODO this is quite CPU expensive because 'retrievedParent' is researched in all projects

			TXMResult retrievedParent = TXMResult.getResult(parentNodePath);

			if (retrievedParent != null) {

					TBXPreferences.delete(this);

				}

				catch(Exception e) {

				}

				return;

			}

		try {

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

			this.loadParameters(); // subclasses manual settings

			try {

				if (creationDate == null) {

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

	public boolean isAltered() {

		return altered;

	}

	/**

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

	 */

	public void setAltered() {

		this.altered = true;

	}

	/**

	 * 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 persistence of this result.

	 * @return

		//this.uniqueID = this.getClass().getName() + '@' + ID_TIME_FORMAT.format(new Date(System.currentTimeMillis())) + "_" + UUID.randomUUID();

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

	}

	/**

	 * 

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

			}

		}

		try {

			if(this.getLastParametersFromHistory().isEmpty())	{

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

	 * @return

	 */

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

		if(lastParameters == null)	{

			return true;

		}

		if (key.isEmpty()) {

			return false;

		}

		}

		boolean hasParameterChanged = false;

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

		for (Field f : fields) {

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

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

			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

	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

	/**

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

	 * @throws Exception

	 */

	public void updateDirtyFromHistory() throws Exception {

		if(this.hasParameterChanged())	{

			this.dirty = true;

		}

	}

	 * @param dirty

	 */

	public void setDirty(boolean dirty) {

		this.dirty = dirty;

		}

	}

	/**

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

	}

	/**

		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.

	 * 

		this.saveParameter("class", this.getClass().getName()); //$NON-NLS-1$

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

		// FIXME: old version that not work well if a bundle has no preference initializer

		//this.saveParameter(TXMPreferences.BUNDLE_ID, this.commandPreferencesNodePath);

		// FIXME: new version

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

		if (this.parent != null)	{

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

		}

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

					// FIXME: do not pass a Serializable for now

					//|| !f.getType().isAssignableFrom(Serializable.class)

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

				continue;

			}

			String key = parameter.key();

			if (key.isEmpty()) {

				else if (f.getType().isAssignableFrom(Date.class)) {

					value = this.getDateParameterValue(key);

				}

				// FIXME: test to automate other type creation as Property => problem here is that org.txm.core doesn't know the plug-in org.txm.searchengine.cqp.core

				// could be done using reflection. Get the field runtime class, then get and call the constructor

				//				else if (f.getType().isAssignableFrom(Property.class)) {

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

			this.clean();

			if (this.parent != null) {

				this.parent.removeChild(this);

			}

			this.parent = null;

			return true;

	/**

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

	 */

		while (todo.size() > 0) {

			TXMResult r = null;

		}

	}

		return false;

	}

	/**

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

	 * @return true 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 void deleteChildren() {

		deleteChildren(null);

	}

	/**

	 * Deletes the children of the specified class.

	 * @param type

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

		return TXMResult.getDeepChildren(this, clazz);

	}

	/**

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

	 * 

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

		return TXMResult.getDeepChildren(r, null);

	}

	/**

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

	 * 

					return results.get(i); // a direct children is the node we are looking for

				}

			}

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

				TXMResult r = getResult(results.get(i), nodePath);

				if (r != null) {

	public boolean isChild(TXMResult child) {

		return this.getDeepChildren().contains(child);

	}

	/**

	 * Gets the sibling nodes of this node result.

	 */

	public boolean isVisible() {

		return this.visible;

	}

	public boolean isParentVisible() {

		return parent != null && (parent.isVisible() || parent.isInternalPersistable());

	}

	 */

	public abstract String getDetails();

	/**

	 * Gets a message indicating the start of computing.

	 * Dedicated to indicate the start of computing and, for example, the parameters used for the computing.

	public String getComputingStartMessage() {

		return "Computing "+this.getClass().getSimpleName()+"...";

	}

	/**

	 * Gets a message indicating the computing is done.

	 * Dedicated to indicate the end of computing and, for example, some informations about the result (eg. : 12 matches found, No matches found, etc.).

	public String getComputingDoneMessage() {

		return "";

	}

	/**

	 * Gets the user name if exists otherwise, the lazy name if exists, otherwise the simple name.

	 * 

		return "..."; //$NON-NLS-1$

	}

	/**

	 * Gets a string representing the result that can be used as a file name (eg. for exporting in file).

	public TXMResult clone() {

		return clone(null, true);

	}

	public TXMResult clone(boolean all) {

		return clone(null, all);

	}

		try {

			String newNodePath = this.getProject().getParametersNodeRootPath()+ createUUID() + "_" + this.getClass().getSimpleName();

			TXMPreferences.cloneNode(this.getParametersNodePath(), newNodePath);

			if (newParent != null) { // change the cloned node parent preference

				TXMPreferences.put(newNodePath, TXMPreferences.PARENT_PARAMETERS_NODE_PATH, newParent.getParametersNodePath());

			}

			clone =  this.getClass().getDeclaredConstructor(String.class).newInstance(newNodePath);

			if (all) {

				for (TXMResult child : this.children) {

					child.clone(clone, all);

		try {

			Properties props = new Properties();

			props.load(IOUtils.getReader(parameters));

			// some tests before...

			String className = props.getProperty("class");

			if (className == null || className.length() == 0) {

				System.out.println("** Error: No class internal parameter set.");

				return false;

			}

			if (this.getClass().getName().equals(className)) {

				for (Object p : props.keySet()) {

					String ps = p.toString();

		}

		return true;

	}

	/**

	 * import a result from a parameter file

	 * @param allparameters the parameters file

		try {

			Properties props = new Properties();

			props.load(IOUtils.getReader(parameters));

			// some tests before...

			String className = props.getProperty("class");

			if (className == null || className.length() == 0) {

				System.out.println("** Error: No class internal parameter set.");

				return null;

			}

			String bundleId = props.getProperty("bundle_id");

			if (bundleId == null || bundleId.length() == 0) {

				System.out.println("** Error: No bundle_id internal parameter set.");

				return null;

			}

			Bundle bundle = Platform.getBundle(bundleId);

			if (bundle == null) {

				Log.finest("** Error: can not restore object with bundle name " + bundleId); //$NON-NLS-1$

				return null;

			}

			// copy parameters

			String newNodePath = this.getProject().getParametersNodeRootPath()+ createUUID() + "_" + className;

			TXMPreferences.put(newNodePath, TXMPreferences.PARENT_PARAMETERS_NODE_PATH, this.getParametersNodePath());

				if (TXMPreferences.RESULT_PARAMETERS_NODE_PATH.equals(ps)) continue;

				TXMPreferences.put(newNodePath, ps, props.getProperty(ps, ""));

			}

			// create instance

			Class<?> cl = bundle.loadClass(className);

			Constructor<?> cons = null;

					clazz = clazz.getSuperclass();

				}

			}

			if (cons == null) {

				System.out.println(NLS.bind("Cannot import {0} in {1}", parameters, this));

			} else {

				System.out.println(NLS.bind("{0} imported", result));

				return result;

			}

		} catch (Exception e) {

			System.out.println(NLS.bind("Fail to import result from {0}: {1}", parameters, e));

			Log.printStackTrace(e);

		}

		return null;

	}

	/**

	 * Set the TXMResult parameters

	 * 

		return this.compute(monitor, true);

	}

	/**

	 * Computes the result if:

	 * - it can be computed (checking if all mandatory parameters are set)

	 * @return

	 */

	protected boolean compute(IProgressMonitor monitor, boolean deepComputing) {

		if (this.computing) {

			return true;

		}

		this.computing = true;

		// no changes to do

		// FIXME: SJ: we need to do do some actions even if the object is locked, eg. updating parameters, saving parameters, etc.

		// FIXME MD: nope the parameters must not move and will be saved in the current state

			this.computing = false;

			return true;

		}

		try {

			Log.finest("*** TXMResult.compute(): " + this.getClass().getSimpleName() + ": starting computing process...");

			// FIXME: SJ: see if this skipComputing tests is still useful? is it possible to directly return instead?

			// en fait voir ChartResult.compute() if(super.compute(monitor, true, false)), je pense que le prob vient du fait que si on retourne false dans TXMResult.compute() alors renderChart() ne sera pas appelé

			// il faudrait retourner un état: skipped, computed, error, etc. 

			// 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.");

			if(!skipComputing)	{

				// Debug

				Log.finest("+++ TXMResult.compute(): " + this.getClass().getSimpleName() + ": computing result of type " + this.getClass() + "...");

				//Log.info(this.getComputingStartMessage());

				// Computing

				if (!this._compute()) {

					Log.finest("TXMResult.compute(): " + this.getClass().getSimpleName() + ": computing failed.");

					this.computing = false;

					return false;

				}

			}

			// clear the lazy name, no more needed since the object has been computed and getSimpleName() can now work

			if(!skipComputing)	{

				// store last used parameters

				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

				}

				if (!this.autoSaveParametersFromAnnotations()) {

					Log.severe("TXMResult.compute(): " + this.getClass().getSimpleName() + ": failed to save parameters from annotations for " + this.getName() + ".");

				}

				this.dirty = false; // the computing was successful, the result is no more dirty

				this.hasBeenComputedOnce = true;

				if (this.altered) {

					Log.finest(NLS.bind("TXMResult.compute(): Warning {0} modifications have been lost.", this.getSimpleName()));

				}

				this.altered = false;

				Log.finest("TXMResult.compute(): " + this.getClass().getSimpleName() + ": computing of result type " + this.getClass() + " done.");

				//Log.info(this.getComputingDoneMessage());

			}

			// Children computing

			if(!skipComputing

					|| this.altered // FIXME: SJ: fix for computing LexicalTable children even if the LT is not dirty but only altered, need to define if it's a temporary fix or not

					)	{

				// set the children as dirty since the result has changed

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

					this.children.get(i).setDirty();

				}

				// Children cascade computing (if parent == null then it is the Workspace (Tree root))

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

					Log.finest("TXMResult.compute(): " + this.getClass().getSimpleName() + ": cascade computing of " + this.children.size() + " child(ren).");

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

						this.children.get(i).compute(monitor, deepComputing);

					}

				}

			}

		}

		catch (Exception e) {

			e.printStackTrace();

				child.setUserPersistable(userPersistable);

			}

		}

		// directly save and flush the preference

		try {

			if (this.isUserPersistable()) {

	public ArrayList<HashMap<String, Object>> getParametersHistory() {

		return parametersHistory;

	}

	/**

	 * Gets the last computing date.

	 * @return the last computing date

	public Date getCreationDate() {

		return this.creationDate;

	}

	public boolean toParametersFile(File outfile) throws IOException {

		return TXMPreferences.flush(this, outfile);

	}

	File pSource;

	/** The XML-TXM file. */

	@Parameter(key=TBXPreferences.XMLTXM)