Laboratoire ICAR » Plateforme TXM

			});

		}

		project.setNeedToBuild();

		project.setDoMultiThread(false); // too soon

		project.setDoUpdate(true);

		Version v = Activator.getDefault().getBundle().getVersion();

		String vv = v.getMajor() + "." + v.getMinor() + "." + v.getMicro(); //$NON-NLS-1$ //$NON-NLS-2$ $NON-NLS-2$

		String SAMPLES = "1. " + TXMUIMessages.bind(TXMUIMessages.sampleCorporaOfCurrentTXMP0, vv);//$NON-NLS-1$

		final ArrayList<Object> corporaDirs = new ArrayList<>();

		corporaDirs.add(SAMPLES);

		corporaDirs.add(V080);

		corporaDirs.add(V079);

		corporaDirs.add(OTHER);

		final ArrayList<Object> initialCorporaDirs = new ArrayList<>();

		initialCorporaDirs.add(SAMPLES);

		Display.getDefault().syncExec(new Runnable() {

			@Override

			}

		}

		// TXM-0.8.0 previous installation corpora

		if (corporaDirs.contains(V080) && backupDir.listFiles(IOUtils.HIDDENFILE_FILTER).length > 0) { // not a new install, restore corpus from the corpora-previous directory

			Log.info(NLS.bind(TXMUIMessages.installingPreviousCorpusFromP0, "0.8.0", corporaDir)); //$NON-NLS-1$

						TXMResult r = (TXMResult) s;

						if (r.importParameters(outfile)) {

							CorporaView.refreshObject(r);

							System.out.println(NLS.bind("Parameter imported from the {0} file.", outfile));

							SWTEditorsUtils.refreshEditors(r);

	}

	@Override

	public boolean setParameters(TXMParameters parameters) {

		// TODO Auto-generated method stub

		System.err.println("SpecificitiesSelection.setParameters(): not yet implemented.");

		if (isSuccessful) { // all done TODO remove this code when Text._compute() will be implemented

			for (Text t : project.getTexts()) {

			}

			project.setDoUpdate(false);

	/**

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

	 */

	/**

	 * The weight, essentially used for sorting purpose.

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

	 * like after updating parameters

	 */

	/**

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

	 */

	/**

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

	/**

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

	 */

	/**

	 * User persistable state.

	 */

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

	/**

	 * The visibility state.

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

	 * 

	 */

	/**

	 * Synchronization state between this result and its parent.

			this.parametersHistory.remove(0);

			this.parametersHistory.remove(0);

		}

	}

	/**

	 * 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.

	 * 

	 */

		if (propagate) {

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

			}

		}

	}

	/**

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

	 * default preferences nodes.

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

		}

			this.lazyName = this.getSimpleName();

		}

			}

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

			if (all) {

				for (TXMResult child : this.children) {

					child.clone(clone, all);

		catch (Exception e) {

			Log.printStackTrace(e);

		}

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

		}

				// store last used parameters

				// this.updateLastParameters();

						|| this.lastComputingDate == null) { // set the update date if never computed once

					this.lastComputingDate = Calendar.getInstance().getTime(); // update this internal parameter before saving parameters

				}

				}

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

				if (this.altered) {

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

			// set back to dirty

			this.dirty = true;

			this.computing = false;

			// FIXME: SJ: old code, used when the monitor was stored in the TXMResult, need to check if we need a replacement for this

			// this.monitorSetCanceled(true);

	}

	/**

	 * Gets a boolean state defining if the result has already been computed at least once or not.

	 * 

	 * true if the result has already been lazy LOADED...........

	 * @return

	 */

	public boolean hasBeenComputedOnce() {

	}

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.Path;

import org.eclipse.core.runtime.Platform;

import org.eclipse.core.runtime.preferences.IEclipsePreferences;

import org.eclipse.osgi.util.NLS;

import org.osgi.framework.Bundle;

		this.needToBuild = needToBuild;

		this.userName = name;

		this.setVisible(false);

		initRCPStuffs(new LogMonitor());

		}

	}

	/**

	 * Instantiates a new existing project from persistence.

	 * This project will not be builded, main corpus, texts, editions, etc. will be restored from persistence.

		super(parametersNodePath);

		this.needToBuild = false;

		this.setVisible(false);

		initRCPStuffs(new LogMonitor());

	}

	public void setSourceFile(File src) {

			this.pSource = src;

		}

	}

	public void setContextSize(int leftsize, int rightsize) {

		this.pLeftContextSize = leftsize;

		this.pRightContextSize = rightsize;

	}

	public void setCQLSeparator(String cql_limit) {

		this.pLeftContextSize = leftContextSize;

		this.pRightContextSize = rightContextSize;

	}

	@Override

		this.pRightContextSize = (Integer) parameters.get(ConcordancePreferences.RIGHT_CONTEXT_SIZE);

		this.saveParameters();

		return true;

	}

		this.pViewLeftProperties = viewProperties;

		this.pViewRightProperties = viewProperties;

		this.pViewKeywordProperties = viewProperties;

		resetLines();

	}

			this.pViewKeywordProperties = new ArrayList<>();

		}

		resetLines();

	}

		if (pattern != null) this.pPattern = pattern;

		if (prop != null) this.pProperty = prop;

		if (hierarchicSort != null) this.pHierarchicSort = hierarchicSort;

	}

	@Override

		// Reset the cached data

		this.resetCache();

		return true;

	}

		if (method != null) {

			this.method = method;

		}

	}

		if (this.hasParameterChanged(InternalViewPreferences.STRUCTURAL_UNIT)) {

			// reset the current page (only if the result has been computed at least once otherwise it breaks the deserialization)

				this.pCurrentPage = 0;

			}

			}

			result.drop();

			// System.out.println(matches);

			return (nmatches > 0);

		}

		return true;

		if (structProperties != null) this.pStructuralUnitsProperties = structProperties;

		if (currentStructure != null) this.pCurrentPage = currentStructure;

	}

		this.domainGridLinesVisible = true;

	}

	@Override

	protected boolean autoLoadParametersFromAnnotations() throws Exception {

		return (super.autoLoadParametersFromAnnotations()

	 */

	protected abstract boolean __compute(TXMProgressMonitor monitor) throws Exception;

	@Override

	protected final boolean _compute(TXMProgressMonitor monitor) {

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

			// FIXME: SJ: Computes the result only if at least one computing parameter has changed

			// }

				computingState = this.renderChart(monitor.createNewMonitor(10));

			}

		}

		super.updateDirtyFromHistory();

			// problem here is that if the object is not dirty, TXMResult.compute() doesn't call ChartResult._compute() so the rendering is not done

		}

	}

	 * @throws Exception

	 */

	public void updateChartDirtyFromHistory() throws Exception {

			this.chartDirty = true;

		}

	}

		// clone.chart = this.chart.clone();

		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;

		return clone;

	}

		monitor.worked(30);

		this.pTopIndex = 0;

		monitor.setTask("Index done.");

		this.cut();

		this.pTopIndex = 0;

		monitor.setTask("Index done.");

	public String getSimpleDetails() {

		try {

				return TXMCoreMessages.bind(TXMCoreMessages.fminP0fmaxP1tP2vP3, getFmin(), getFmax(), getT(), getV());

			}

			else {

	/** The count. */

	HashMap<String, Integer> count;

	// contains the sum of distances

	/** The counts. */

	HashMap<String, Integer> counts = new HashMap<>();

	/** The distances. */

	HashMap<String, Double> distances = new HashMap<>();

	/** The FA. */

	int FA = -1;

	/** The m1. */

	private List<Match> m1;

	/** The m2. */

	private List<Match> m2;

	@Override

	protected boolean _compute(TXMProgressMonitor monitor) throws CqiClientException, IOException, CqiServerError, StatException {

		// System.out.println("cooc: "+corpus+" "+query+" "+properties+" "+limit+" "+maxLeft+" "+minLeft+" "+minRight+" "+maxRight+" "+minFreq+" "+minCof+" "+minScore+" "+includeXpivot);

		monitor.setTask(CooccurrenceCoreMessages.info_buildingQueries);

			this.allsignaturesstr.clear();

			this.conclines.clear();

			this.count.clear();

			this.counts.clear();

			this.dist.clear();

			this.distances.clear();

			this.indexfreqs.clear();

			this.keysToString.clear();

			this.occproperties.clear();

	// FIXME: useless?

	public void clearMemory() {

		if (distances != null) distances.clear();

		if (counts != null) counts.clear();

		if (indexfreqs != null) indexfreqs.clear();

		if (m1 != null) m1.clear();

		if (m2 != null) m2.clear();

		if (m3 != null) m3.clear();

			CQPCorpus corpus = this.getCorpus();

			this.concordance = conc;

			corpus = conc.getCorpus();

			this.FA = conc.getNLines();

			corpus = conc.getCorpus();

			pQuery = new CQLQuery(conc.getQuery().getQueryString()); // TODO manage all kind of query

			Object propsParam = parameters.get(CooccurrencePreferences.UNIT_PROPERTIES);

			List<WordProperty> properties = null;

				properties = (List<WordProperty>) propsParam;

			}

			else if (propsParam instanceof String) {

				index.alterFrequencies(referenceCorpus);

			}

			catch (Exception e) {

				org.txm.utils.logger.Log.printStackTrace(e);

				return false;

			}

	 * @return true, if successful

	 */

	public boolean stepCount() {

		int startsearchM2 = 0; // optimisation: m2 is ordered

		int startsearchM3 = 0; // optimisation: m3 is ordered

				// System.out.print(" "+position);

			}

				if (o.getStart() <= position && position <= o.getEnd()) {

					// ignore positions in the anticontext positions

					continue;

				}

				if (!distances.containsKey(signaturestr)) {

					distances.put(signaturestr, 0.0);

				}

				}

				noOcc++;

			}

	public boolean stepGetMatches() throws CqiClientException {

		CQPCorpus corpus = this.getCorpus();

		QueryResult r1 = corpus.query(pQuery, "CoocFocusQuery", false); // keywords positions //$NON-NLS-1$

		m1 = r1.getMatches();

		numberOfKeyword = m1.size();

		m2 = r2.getMatches();

		m3 = r3.getMatches();

		// System.out.println(query+" M1 size: "+m1.size());

		// System.out.println(contextquery+" M2 size: "+m2.size());

		// System.out.println(anticontextquery+" M3 size: "+m3.size());

		r1.drop();

		return true;

	}

			// System.out.println("distance count: "+distancescounts.get(signaturestr));

			// }

			if (counts.containsKey(signaturestr)) {

				if (cline.freq >= this.pFminFilter && cline.nbocc >= this.pFCoocFilter && cline.score >= 0 && cline.score >= this.pScoreMinFilter) {

					if (cline.score >= Integer.MAX_VALUE - 5) {

						cline.score = Float.MAX_EXPONENT;

		if (this.pMaxPropertiesToDisplay <= 0) {

			this.pMaxPropertiesToDisplay = 10;

		}

	}

	protected boolean _load(Element e) {

		// partition already computed

			return true;

		}

	@Override

	public void onProjectClose() {

		try {

				CorpusManager.getCorpusManager().deleteCorpus(this);

			}

		}

	 */

	@Override

	public int getSize() throws CqiClientException {

		if (this.size == -1) {

			try {

		super.clean();

		// nothing to do if the corpus has not yet been computed

			try {

				AbstractCqiClient CQI = CorpusManager.getCorpusManager().getCqiClient();

				if (CQPSearchEngine.isInitialized()) {

	 */

	@Override

	public int getSize() throws CqiClientException {

		if (this.size == -1) {

			// Log.finest(TXMCoreMessages.bind(TXMCoreMessages.SUBCORPUS_SIZE, new Object[]{this.pName, "N/A"}));

		this.pQuery = queryResult.getQuery();

		this.qresult = queryResult;

	}

	@Override

		if (useAllOccurrences != null) {

			this.useAllOccurrences = useAllOccurrences;

		}

	}

	/**