Laboratoire ICAR » Plateforme TXM

import org.txm.core.engines.Engine;

import org.txm.objects.CorpusBuild;

// FIXME: useless class

public abstract class SearchEngine implements Engine {

	@Override

	public abstract String getName();

	public abstract Selection query(CorpusBuild corpus, Query query, String name, boolean saveQuery) throws Exception;

	public abstract Query newQuery();

			while (null != (ze = zis.getNextEntry())) {

				nEntries++;

			}

			if (zis != null) zis.close();

		}

		//System.out.println("count entries result: "+nEntries);

			}

		} finally {

			zis.close();

		}

		if (deleteZipAfter)

			// Parcours tous les fichiers

			while (null != (ze = zis.getNextEntry())) {

				String currentpath = ze.getName();

					if (toFind.size() == 0) {

						try {

							zis.close();

				try {

					Subcorpus subcorp = this.createSubcorpus(subcorpusElem);

					subcorp._load(subcorpusElem);

				} catch (CqiClientException ex) {

					Log.warning(this.pID + TXMCoreMessages.Corpus_12 + pID

							+ " : " + ex); //$NON-NLS-1$

//					partition.setSelfElement(partitionElem);

//					partition.load();

				} catch (Exception ex) {

					Log.warning(this.pID + TXMCoreMessages.Corpus_19 + name

							+ " : " + ex); //$NON-NLS-1$

	 */

	public MainCorpus(String parametersNodePath) throws InvalidCqpIdException, CqiClientException {

		super(parametersNodePath);

	}

	@Override

	public boolean export(File exportzip, IProgressMonitor monitor)

	{

		return false;

	}

import org.txm.core.results.Parameter;

import org.txm.core.results.TXMParameters;

import org.txm.searchengine.cqp.AbstractCqiClient;

import org.txm.searchengine.cqp.NetCqiClient;

import org.txm.searchengine.cqp.clientExceptions.CqiClientException;

import org.txm.searchengine.cqp.clientExceptions.InvalidCqpIdException;

	@Override

	public void clean() {

		try {

		} catch (Exception e) {

			e.printStackTrace();

		}

					((MemCqiClient)cqiClient).dropCorpus(name);

				}

			}

			cqiClient.disconnect();

			cqiServer.stop();

import org.txm.objects.Edition;

import org.txm.objects.Project;

import org.txm.objects.Text;

import org.txm.searchengine.cqp.CQPSearchEngine;

import org.txm.tokenizer.TokenizerClasses;

import org.txm.utils.ExecTimer;

		try {

			// check if TreeTagger is ready

			boolean annotate = project.getAnnotate();

			if (annotate) {

				Engine e = Toolbox.getEngineManager(EngineType.ANNOTATION).getEngine("TreeTagger");

import org.txm.core.preferences.TBXPreferences;

import org.txm.core.preferences.TXMPreferences;

import org.txm.objects.Project;

import org.txm.rcp.commands.OpenWelcomePage;

import org.txm.rcp.commands.RestartTXM;

import org.txm.rcp.commands.workspace.LoadBinaryCorpus;

import org.txm.searchengine.core.SearchEnginesManager;

import org.txm.utils.BundleUtils;

import org.txm.utils.DeleteDir;

import org.txm.utils.logger.Log;

import org.txm.utils.zip.Zip;

						// restore corpora if TXMHOME has been created

						if (txmHomeRestored) {

							//createBackUpDirectory(monitor);

							this.syncExec(new Runnable() {

								@Override

								public void run() {

									try {

										SearchEnginesManager.getCQPSearchEngine().stop();

										SearchEnginesManager.getCQPSearchEngine().start(monitor);

										CorporaView.refresh();

		}

	}

		String installdirpath = Toolbox.getInstallDirectory();

		File sampleCorporaDirectory = new File(installdirpath, "samples");

		// load corpora from the install directory

		if (sampleCorporaDirectory.exists()) { //$NON-NLS-1$

			Log.info(TXMUIMessages.ApplicationWorkbenchAdvisor_11);

			monitor.setTaskName(TXMUIMessages.ApplicationWorkbenchAdvisor_11);

			//File corporaDir = new File(txmhomedir.getAbsolutePath(), "corpora"); //$NON-NLS-1$

			File[] sampleCorpusFiles = sampleCorporaDirectory.listFiles(); //$NON-NLS-1$

							System.out.println(NLS.bind(TXMUIMessages.AddBase_31, e));

						}

					} else if (zipFile.isDirectory()) {

					} else {

						System.out.println(NLS.bind(TXMUIMessages.AddBase_22, zipFile));

						System.out.println(TXMUIMessages.AddBase_25);

						continue;

					}

				} catch (Exception e) {

					System.out.println(TXMUIMessages.ApplicationWorkbenchAdvisor_51+zipFile);

					org.txm.rcp.utils.Logger.printStackTrace(e);

				}

			}

		}

		// after loading sample corpora, restore older corpus

//		if (backup.exists()) {

					//project._load(params);

				}

				return true;

			} catch (Exception e) {

				e.printStackTrace();

			Workspace w = Toolbox.workspace;

			if (w == null) return;

		}

	}

		if (allObjectDeleted.size() > 0) {

			if (shouldRestartToolbox) {

				Toolbox.getEngineManager(EngineType.SEARCH).restartEngines();

				Log.info(TXMUIMessages.info_txmIsReady);

	/**

	 * Deletes the specified object.

	 *

	 * @param o the o

	 * @return the list

//		}

//		// FIXME: when TXMResult will be implemented, only this code must be left

		if (o instanceof TXMResult) {

			Log.info(NLS.bind(TXMUIMessages.DeleteObject_10, ((TXMResult) o)));

			deleted.add(o);

		} else {

		if (successfulSave) {

			try {

				//				DomUtils.save(params.root.getOwnerDocument(), paramFile);

			} catch (Exception e1) {

				org.txm.rcp.utils.Logger.printStackTrace(e1);

		String basedirname = Zip.getRoot(zipFile);

			return null;

		}

			return null;

		}

		return base;

	}

}

						converter.start();

						this.releaseSemaphore();

						if (base == null) {

							System.out.println(TXMUIMessages.ConvertCorpus_0);

							return Status.CANCEL_STATUS;

						}

						this.acquireSemaphore();

						Toolbox.getEngineManager(EngineType.SEARCH).restartEngines();

						this.releaseSemaphore();

package org.txm.rcp.commands.workspace;

import java.io.File;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.eclipse.swt.SWT;

import org.eclipse.swt.widgets.DirectoryDialog;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.ui.handlers.HandlerUtil;

import org.txm.Toolbox;

import org.txm.core.engines.EngineType;

import org.txm.objects.Project;

import org.txm.rcp.StatusLine;

import org.txm.rcp.commands.RestartTXM;

import org.txm.rcp.messages.TXMUIMessages;

import org.txm.rcp.swt.dialog.LastOpened;

import org.txm.rcp.utils.JobHandler;

/**

 *

 * @author mdecorde

 */

			if (directory.exists()) {

				LastOpened.set(ID, directory);

			}

		}

		return null;

	 * @param directory

	 * @return

	 */

		JobHandler jobhandler = new JobHandler("Scanning "+directory+"...", true) {

			@Override

			protected IStatus run(IProgressMonitor monitor) {

				this.runInit(monitor);

				File corporaDirectory = new File(Toolbox.getTxmHomePath(), "corpora");

				if (!corporaDirectory.exists()) {

					System.out.println("Corpora directory not found. Aborting.");

					return Status.CANCEL_STATUS;

				}

				try {

						}

					}

				}

			}

	}

}

		String basedirname = Zip.getRoot(zipFile);

			return null;

		}

import org.txm.searchengine.core.SearchEnginesManager;

import org.txm.searchengine.cqp.corpus.MainCorpus;

import org.txm.utils.DeleteDir;

import org.txm.utils.logger.Log;

import org.txm.utils.zip.Zip;

/**

 *

 * @author mdecorde

 */

		return null;

	}

	/**

	 * Load a binary corpus archive: 

	 * 

	 * 4- load the binary corpus directory

	 * 5- restart TXM engines

	 */

		String filename = zipFile.getName();

		final File corporaDir = Toolbox.workspace.getLocation();

			return false;

		}

		}

		//build binary dir path			

		if (corpusdir.exists()) {

			boolean b = MessageDialog.openConfirm(Display.getCurrent().getActiveShell(), TXMUIMessages.AddBase_19, NLS.bind(TXMUIMessages.AddBase_20, corpusdir.getName().toUpperCase()));

				Project p = Toolbox.workspace.getProject(basedirname);

				if (p != null) {

				} else {

					DeleteDir.deleteDirectory(corpusdir);

				}

				if (corpusdir.exists()) {

					System.out.println("Error: previous binary corpus directory was not deleted: "+corpusdir);

					return false;

				}

			} else {

				return false; // abandon

			}

		}

			@Override

			protected IStatus run(final IProgressMonitor monitor) {

				this.runInit(monitor);

							RestartTXM.reloadViews();

							//System.out.println("Select newly loaded corpus: "+base2.getCorpora().values());

							CorporaView.select(newProject2.getChildren(MainCorpus.class));

							System.err.println(TXMUIMessages.info_txmIsReady);

							StatusLine.setMessage(TXMUIMessages.info_txmIsReady);

						}

					}

				return Status.OK_STATUS;

				//return Status.CANCEL_STATUS;

			}

		return true;

	}

	/**

	 * load the content of the file if its a directory containing at least the sub folders :

	 * @return the base

	 * @throws Exception the exception

	 */

			return null; 

		}

		}

	}

}

import org.txm.Toolbox;

import org.txm.core.preferences.TBXPreferences;

import org.txm.objects.Project;

import org.txm.rcp.handlers.scripts.ExecuteImportScript;

import org.txm.rcp.messages.TXMUIMessages;

import org.txm.searchengine.cqp.corpus.CorpusManager;

		// configure project

		if (project == null) {	

		}

		project.setSourceDirectory(clipboardDirectory.getAbsolutePath());

		project.setImportModuleName("txt");

      <product

            application="org.txm.rcp.Application"

            description="%product.description"

         <property

               name="appName"

               value="TXM">

            </command>

            <command

                  commandId="org.txm.rcp.handlers.results.SetTXMResultPersistentState"

                  mode="FORCE_TEXT"

                  style="toggle">

               <visibleWhen

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

	 */

	protected String parametersNodePath;

	/**

	 * If set, allows the command to notify its progress.

	 */

	// The problem is since the result is already computing, the parameters are already updated and the method hasParameterChanged() will always return false. Using this stack fix the problem.

	// But this stack is also the start for an UNDO command on TXMResult.

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

	/**

	 * Internal persistable state.

	 */

	 */

	protected boolean userPersistable;

	/**

	 * The visibility state.

	 */

	/**

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

	 * @param parent

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

		}

		if (parametersNodePath == null)	{

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

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

		Log.finest("TXMResult.TXMResult(): parameters node path: " + this.parametersNodePath);

		this.weight = 0;

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

		this.commandPreferencesNodePath = FrameworkUtil.getBundle(getClass()).getSymbolicName(); //$NON-NLS-1$

		Log.finest("TXMResult.TXMResult(): command preferences node path: " + this.commandPreferencesNodePath);

		this.visible = true;

		this.dirty = true;

		this.internalPersistable = false;

		// retrieving parent from UUID

		String parentUUID = this.getStringParameterValue(TXMPreferences.PARENT_UUID);

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

		if (!("ROOT".equals(this.uniqueID)) && // search for parent only if UUID != "ROOT"

				parent == null && 

				this.uniqueID != null && 

			Log.severe("Fail to load " + uniqueID + "result: " + e);

			Log.printStackTrace(e);

		}

		// Log

		if (this.parent == null)	{

			Log.warning("Warning: the TXMResult of " + this.getClass() + " is attached to no parent. (uuid = " + this.getUUID() + ")");

		}

		try {

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

			//this.updateLastParameters();

		//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())) + "_" + UUID.randomUUID();

	}

	/**

	 * Checks if the result at least one child.

	 * @return

		return this.children.size() > 0;

	}

	/**

	 * Gets the preferences node path of the result command.

	 * 

		return this.commandPreferencesNodePath;

	}

	public String[] getCommandPreferencesKeys() throws BackingStoreException {

		return TXMPreferences.getCommandScopeKeys(this.commandPreferencesNodePath);

	}

	public Object getParameter(String key) {

		return getParameter(key, false);

	}

	/**

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

	 * @param key

		List<Field> fields = new ArrayList<Field>();

		Class<?> clazz = this.getClass();

		while (clazz != Object.class) {

			fields.addAll(Arrays.asList(clazz.getDeclaredFields()));

			clazz = clazz.getSuperclass();

	protected void updateLastParameters(int parameterType, boolean appendToLastParameters) throws Exception {

		HashMap<String, Object> lastParameters;

		if(appendToLastParameters)	{

			lastParameters = this.getLastParametersFromHistory();

		}

		else	{

			lastParameters = new HashMap<>();

		}

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

		for (Field f : fields) {

			f.setAccessible(true);

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

		}

		if(!appendToLastParameters)	{

			this.parametersHistory.add(lastParameters);

		}

		// truncate the stack to the max count

		// FIXME: store this in a TBX preference

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

			this.parametersHistory.remove(0);

			this.parametersHistory.remove(0);

		}

	}

	/**

	 * Stores the last parameters used for computing.

	 * @throws Exception

		if (this.isDirty()) {

			return true;

		}

		Object lastValue = lastParameters.get(key);

		Object newValue = this.getParameter(key);

		if (lastValue == null) {

	 * @throws IllegalArgumentException 

	 */

	public final boolean isDirtyFromHistory() throws Exception {

		Class clazz = this.getClass();

		Field[] fields = clazz.getDeclaredFields();

			}

			f.setAccessible(true); // to be able to test the field values

			Object previousValue = this.getLastParametersFromHistory().get(name);

			Object newValue = f.get(this);

			this.updateDirty(previousValue, newValue);

			if (this.dirty) {

		return this.dirty;

	}

	public HashMap<String, Object> getLastParametersFromHistory()	{

		return this.parametersHistory.get(this.parametersHistory.size() - 1);

	}

	/**

	 * Gets the dirty state.

	 * 

	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

		// internal data to save for unserialization

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

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

		this.saveParameter(TXMPreferences.RESULT_UUID, this.uniqueID);

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

					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)

					// FIXME: do not pass a Serializable for now

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

					//|| !Serializable.class.isInstance(f)

					) {

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

				try {

					Object value = f.get(this);

	 */

	public abstract boolean saveParameters() throws Exception;

	/**

	 * 

	 * @return

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

		return setParameter(key, value, false);

	}

	/**

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

	 * @param key

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

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

				c.delete(); // should call parent.removeResult(child)

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

			children.get(i).delete();

		}

	}

	/**

	 * Gets the first child.

	 * @param classSimpleName

						&& (onlyVisible == false || child.isVisible())) {

					nodes.add(child);

				}

				// add children of a non visible result

				else if (!child.isVisible() && child.hasChildren())	{

					List<TXMResult> subChidlren = child.getChildren(type, onlyVisible);

	public int getChildrenCount() {

		return this.children.size();

	}

	/**

	 * Gets the root parent of the branch.

	 * @return

				if(parent.getClass().equals(type)) {

					node = parent;	

				}

				parent = parent.getParent();

			}

		} while (parent != null && node == null);

		return node;

	}

	//	/**

	//	 * Gets the first parent of the specified class, eg. this.getFirstParent(Partition.class);

	//	 * Returns the object itself if it is of the specified class.

	protected boolean compute(IProgressMonitor monitor, boolean deepComputing) {

		try {

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

			// FIXME: 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é 

			boolean skipComputing = false;

			// SJ: other way, test the object itself

			// FIXME: this code shoud be moved back in the !skipComputing section ?

			if (this.parent != null && !(this.parent instanceof Project)) {

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

				if (!this.parent.compute(monitor, true)) {

					Log.severe("TXMResult.compute(): " + this.getClass().getSimpleName() + ": failed to compute parent result.");

					return false;

				}

			}

			boolean d1 = this.isDirtyFromHistory();

			boolean d2 = this.isDirty();

			if (!d1 && !d2) {

				// TODO where do we put this parent compute ? :o

				//		if (parent != null && !parent.getHasBeenComputedOnce()) { // parent must be computed at least one time

				// SJ: other way, test the object itself

				// Computing requirements test

				if (!this.canCompute()) {

					Log.severe("TXMResult.compute(): " + this.getClass().getSimpleName() + ": can not compute, missing or wrong parameters or error with parent computing, computing aborted.");