Laboratoire ICAR » Plateforme TXM

import org.txm.objects.Match;

	protected void affectAnnotationValues(final List<? extends Match> matches,  final AnnotationType type, final String svalue, JobHandler job) {

	protected void affectMatchesToSelection(final List<? extends Match> matches) {

					List<? extends Match> matches = concordance.getMatches();

				} catch (Exception e1) {

import org.txm.objects.Match;

import org.txm.objects.Match;

						List<? extends Match> matches = concordance.getMatches();

					} catch (Exception e1) {

	protected void affectMatchesToSelection(final List<? extends Match> matches) {

	protected void deleteAnnotationValues(List<? extends Match> matches, AnnotationType type, JobHandler job) {

	protected void affectAnnotationValues(final List<? extends Match> matches,  final AnnotationType type, final String svalue, JobHandler job) {

import org.txm.objects.Match;

						List<? extends Match> matches = concordance.getMatches();

					} catch (Exception e1) {

	protected void affectMatchesToSelection(final List<? extends Match> matches) {

	protected void deleteAnnotationValues(List<? extends Match> matches, AnnotationType type, JobHandler job) {

	protected void affectAnnotationValues(final List<? extends Match> matches,  final AnnotationType type, final String svalue, JobHandler job) {

import org.txm.objects.Match;

import org.txm.objects.Match2P;

				matches.add(new Match2P(startPos, endPos));

	public List<Annotation> getAnnotations(AnnotationType type, List<? extends Match> matches, String value, boolean ordered, boolean overlap) throws Exception {

import org.txm.objects.Match;

import org.txm.objects.Match2P;

	public boolean deleteAnnotations(AnnotationType type, List<? extends Match> matches, IProgressMonitor job) throws Exception {

			TypedValue annotSelectedTypedValue, List<? extends Match> matches, IProgressMonitor job) {

			temporaryAnnotations = tempManager.getAnnotations(type, Arrays.asList(new Match2P(start, end)), null, false, overlap);

import org.txm.objects.Match;

import org.txm.objects.Match2P;

		return getAnnotations(type, new Match2P(start, end), null, false);

		return getAnnotations(type, new Match2P(start, end), null, overlap);

	public boolean equals(Query q);

import java.util.ArrayList;

import org.txm.objects.Match;

	public abstract boolean delete(int iMatch);

	public abstract boolean delete(Match match);

	public abstract boolean delete(ArrayList<Match> matchesToRemove);

import java.util.List;

import org.txm.objects.Match;

public abstract class SearchEngine implements ISearchEngine {

	/**

	 * 

	 * @param match

	 * @param property

	 * @return the first position property value

	 */

	public abstract String getValueForProperty(Match match, SearchEngineProperty property);

	/**

	 * 

	 * @param match

	 * @param property

	 * @return the positions property value

	 */

	public abstract List<String> getValuesForProperty(Match match, SearchEngineProperty property);

package org.txm.searchengine.core;

/**

 * A SearchEngine queryable property for match positions

 * 

 * @author mdecorde

 *

 */

public interface SearchEngineProperty {

	/**

	 * 

	 * @return the property uniq name in the queried corpus

	 */

	public String getName();

}

import org.txm.objects.Match;

	@Override

	public boolean delete(int iMatch) {

		// nothing to do

		return false;

	}

	@Override

	public boolean delete(Match match) {

		// nothing to do

		return false;

	}

	@Override

	public boolean delete(ArrayList<Match> matchesToRemove) {

		return false;

	}

package org.txm.searchengine.core;

import org.txm.core.engines.Engine;

import org.txm.objects.CorpusBuild;

public interface ISearchEngine extends Engine {

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

	/**

	 * 

	 * @return an empty Query for the engine implementation

	 */

	public Query newQuery();

	/**

	 * 

	 * @param corpus

	 * @return true if the Engine can query the corpus

	 */

	public abstract boolean hasIndexes(CorpusBuild corpus);

	public String getDetails();

}

				query = (CQLQuery) conc.getQuery(); //TODO manage all kind of Query

import org.txm.objects.Match;

import org.txm.objects.Match;

import org.txm.searchengine.core.SearchEngine;

import org.txm.searchengine.cqp.corpus.query.Match;

		SearchEngine se = ce.getConcordance().getQuery().getSearchEngine();

				String textid = line.getTextId();//line.getMatch().getValueForProperty(textP);// get text via text struc property id

					sStartTime = Match.getValueForProperty(startProperty, line.getMatch().getStart());

					sEndTime =  Match.getValueForProperty(endProperty, line.getMatch().getStart());

	public abstract void setIsModified(boolean b);

	public abstract CorpusBuild getRootCorpusBuild();

	public abstract List<? extends Match> getMatches();

package org.txm.objects;

import java.util.ArrayList;

import java.util.List;

public abstract class Match implements Comparable<Match> {

	public abstract int getStart();

	public abstract int getEnd();

	public abstract int getTarget();

	public boolean contains(Match m) {

		return (this.getStart() <= m.getStart() && m.getEnd() <= this.getEnd());

	}

	/* (non-Javadoc)

	 * @see java.lang.Comparable#compareTo(java.lang.Object)

	 */

	@Override

	public int compareTo(Match m) {

		if (m == null)

			return -1;

		if (this.getStart() < m.getStart())

			return -1;

		else if (this.getStart() > m.getStart())

			return 1;

		else if (this.getEnd() < m.getEnd())

			return -1;

		else

			return 1;

	}

	/* (non-Javadoc)

	 * @see java.lang.Object#toString()

	 */

	@Override

	public String toString() {

		return "<" + this.getStart() + ", " + this.getEnd() + ">"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

	}

	/**

	 * Size.

	 *

	 * @return the int

	 */

	public int size() {

		return getEnd() - getStart() + 1;

	}

	public List<Integer> getRange() {

		List<Integer> ret = new ArrayList<Integer>(size());

		for (int i = getStart() ; i <= getEnd(); i++) ret.add(i);

		return ret;

	}

	public abstract void setEnd(int p);

	public abstract void setStart(int p);

	public abstract void setTarget(int p);

}

package org.txm.objects;

/**

 * A simple Match implementation with 2 positions: start and end

 * 

 * @author mdecorde

 *

 */

public class Match2P extends  Match {

	protected int start;

	protected int end;

	public Match2P(int start, int end) {

		this.start = start;

		this.end = end;

	}

	@Override

	public int getStart() {

		return start;

	}

	@Override

	public int getEnd() {

		return end;

	}

	@Override

	public int getTarget() {

		return -1;

	}

	@Override

	public void setEnd(int p) {

		end = p;

	}

	@Override

	public void setStart(int p) {

		start = p;

	}

	@Override

	public void setTarget(int p) {	}

}

   <extension

         point="org.txm.searchengine.core.SearchEngine">

      <SearchEngine

            class="org.txm.annotation.urs.search.URSSearchEngine">

      </SearchEngine>

   </extension>

 org.txm.annotation.urs.search,

 org.txm.macro.urs.cqp,

package org.txm.annotation.urs.search;

import java.util.ArrayList;

import java.util.Collections;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.regex.Pattern;

import org.eclipse.core.runtime.IProgressMonitor;

import org.txm.annotation.urs.URSCorpora;

import org.txm.core.results.TXMResult;

import org.txm.objects.CorpusBuild;

import org.txm.objects.Match;

import org.txm.searchengine.core.Query;

import org.txm.searchengine.core.SearchEngine;

import org.txm.searchengine.core.SearchEngineProperty;

import org.txm.searchengine.core.Selection;

import org.txm.utils.logger.Log;

import visuAnalec.donnees.Corpus;

import visuAnalec.elements.*;

public class URSSearchEngine extends SearchEngine {

	public URSSearchEngine() {

		// TODO Auto-generated constructor stub

	}

	@Override

	public boolean isRunning() {

		return true;

	}

	@Override

	public boolean initialize() throws Exception {

		return true;

	}

	@Override

	public boolean start(IProgressMonitor monitor) throws Exception {

		return true;

	}

	@Override

	public boolean stop() throws Exception {

		return true;

	}

	@Override

	public void notify(TXMResult r, String state) {

		// nothing

	}

	@Override

	public String getName() {

		return "URS";

	}

	@Override

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

		ArrayList<Element> elements = findAllInCorpus(0, URSCorpora.getCorpus(corpus), corpus, Unite.class, query.getQueryString());

		ArrayList<URSMatch> matches = new ArrayList<URSMatch>();

		for (Element e : elements) {

			matches.add(new URSMatch(e.getUnite0().getDeb(), e.getUnite0().getFin()));

		}

		return new URSSelection(query, matches);

	}

	static String[] getFilterParameters(String URSQL) {

		String type = "";

		String prop = "";

		String value = "";

		if (URSQL == null) return new String[] {type, prop, value};

		int atidx = URSQL.indexOf("@");

		int equalidx = URSQL.indexOf("=");

		if (atidx >= 0 && equalidx >= 0 && atidx < equalidx) {

			type = URSQL.substring(0, atidx);

			prop = URSQL.substring(atidx+1, equalidx);

			value = URSQL.substring(equalidx+1);

		} else if (atidx >= 0) {

			type = URSQL.substring(0, atidx);

			prop = URSQL.substring(atidx+1);

		} else if (equalidx >= 0) {

			type = URSQL.substring(0, equalidx);

			value = URSQL.substring(equalidx+1);

		} else {

			type = URSQL;

		}

		//	println(["'"+type+"'", "'"+prop+"'", "'"+value+"'"])

		return new String[] {type, prop, value};

	}

	static ArrayList<Element> findAllInCorpus(int debug, Corpus analecCorpus, CorpusBuild corpus, Class elemClazz, String URSQL) {

		String[] params = getFilterParameters(URSQL);

		if (debug >= 2) Log.finer("PARAMS=$params");

		return findAllInCorpus(debug, analecCorpus, corpus, elemClazz, params[0], params[1], params[2]);

	}

	static ArrayList<Element> findAllInCorpus(int debug, Corpus analecCorpus, CorpusBuild corpus, Class elemClazz, String typeRegex, String propName, String valueRegex) {

		ArrayList<Element> allElements = new ArrayList<Element>();

		if (elemClazz != null) {

			if (elemClazz == Unite.class)

				allElements.addAll(analecCorpus.getToutesUnites());

			else if (elemClazz == Relation.class)

				allElements.addAll(analecCorpus.getToutesRelations());

			else if (elemClazz == Schema.class)

				allElements.addAll(analecCorpus.getTousSchemas());

		} else {

			allElements.addAll(analecCorpus.getToutesUnites());

			allElements.addAll(analecCorpus.getToutesRelations());

			allElements.addAll(analecCorpus.getTousSchemas());

		}

		return filterElements(debug, allElements, corpus, typeRegex, propName, valueRegex);

	}

	/**

	 * group units by CQP match

	 * 

	 * units are sorted for faster processing

	 * 

	 * @param allUnites

	 * @param matches

	 * @param strict_inclusion

	 * @return

	 */

	static LinkedHashMap groupByMatch(int debug, ArrayList<Element> allUnites, List<? extends Match> matches, boolean strict_inclusion) {

		if (debug >= 2) Log.finer("group "+allUnites.size()+" units with "+matches.size()+" strict=$strict_inclusion");

		//println allUnites.collect() {it -> it.getDeb()}

		Collections.sort(allUnites);// { a, b -> a.getDeb() <=> b.getDeb() ?: a.getFin() <=> b.getFin() };

		//println allUnites.collect() {it -> it.getDeb()}

		int unitsSize = allUnites.size();

		int iCurrentUnit = 0;

		ArrayList<Element> selectedUnits = new ArrayList<Element>();

		int matchesSize = matches.size();

		int iCurrentMatch = 0;

		LinkedHashMap<Match, ArrayList<Element>> selectedUnitsPerMatch = new LinkedHashMap<Match, ArrayList<Element>>();

		selectedUnitsPerMatch.put(matches.get(iCurrentMatch), selectedUnits);

		while (iCurrentMatch < matchesSize && iCurrentUnit < unitsSize) {

			if (debug >= 2) Log.finer("** M $iCurrentMatch < $matchesSize && U $iCurrentUnit < $unitsSize");

			Element e = allUnites.get(iCurrentUnit);

			Unite unit = e.getUnite0();

			Match match = matches.get(iCurrentMatch);

			if (debug >= 3) Log.finer(""+unit.getDeb()+"->"+unit.getFin()+"	"+match.getStart()+"->"+match.getEnd());

			if (unit.getFin() < match.getStart()) {

				if (debug >= 3) Log.finer("next unit");

					iCurrentUnit++;

			} else if (unit.getDeb() > match.getEnd()) {

				if (debug >= 3) Log.finer("next match");

					iCurrentMatch++;

				selectedUnits = new ArrayList<Element>();

				selectedUnitsPerMatch.put(match, selectedUnits);

			} else {

				if (debug >= 3) Log.finer("iCurrentUnit=$iCurrentUnit	iCurrentMatch=$iCurrentMatch");

				if (strict_inclusion) {

					if (debug >= 3) Log.finer("m.start ${match.getStart()} <= u.deb ${unit.getDeb()} && u.fin ${unit.getFin()} <= m.end ${match.getEnd()}");

					if (match.getStart() <= unit.getDeb() && unit.getFin() <= match.getEnd()) {

						selectedUnits.add(unit);

					}

				} else {

					selectedUnits.add(unit);

				}

				iCurrentUnit++;

			}

		}

		return selectedUnitsPerMatch;

	}

	static ArrayList<Element> filterUniteByInclusion(int debug, ArrayList<Element> allUnites, List<? extends Match> matches, boolean strict_inclusion, int limit_distance) {

		LinkedHashMap<Match, ArrayList<Element>> selectedUnitsPerMatch = groupByMatch(debug, allUnites, matches, strict_inclusion);

		//println "selectedUnitsPerMatch size="+selectedUnitsPerMatch.size()

		ArrayList<Element> selectedUnits = new ArrayList<Element>();

		if (limit_distance != 0) {

			if (limit_distance > 0) limit_distance--;

			for (Match m : selectedUnitsPerMatch.keySet()) {

				ArrayList<Element> units = selectedUnitsPerMatch.get(m);

				if (units.size() > limit_distance && units.size() > 0) {

					//println "$m -> "+units.collect() {it -> it.getDeb()}

					Collections.sort(units);

					//println "$m -> "+units.collect() {it -> it.getDeb()}

					selectedUnits.add(units.get(limit_distance));

					if (debug >=3) Log.finer("dist select: "+units.get(limit_distance).getUnite0().getDeb());

				}

			}

		} else {

			for (Match m : selectedUnitsPerMatch.keySet()) selectedUnits.addAll(selectedUnitsPerMatch.get(m));

		}

		return selectedUnits;

	}

	static ArrayList<Element> filterElements(int debug, ArrayList<Element> allElements, CorpusBuild corpus, String typeRegex, String propName, String valueRegex) {

		if (debug >= 2) Log.finer("filtering "+allElements.size()+" elements with typeRegex='$typeRegex' propName='$propName' and valueRegex='$valueRegex'");

		if (corpus != null) {

			allElements = filterUniteByInclusion(debug, allElements, corpus.getMatches(), true, 0);

		}

		if (typeRegex != null && typeRegex.length() > 0) {

			ArrayList<Element> filteredElements = new ArrayList<Element>();

			Pattern pattern = Pattern.compile(typeRegex);

			for (Element element : allElements) {

				if (pattern.matcher(element.getType()).matches()) {

					filteredElements.add(element);

				}

			}

			allElements = filteredElements;

		}

		if (debug >= 2) Log.finer(" type step result: "+allElements.size());

		if (propName != null && propName.length() > 0) {

			ArrayList<Element> filteredElements = new ArrayList<Element>();

			if (valueRegex != null && valueRegex.length() > 0) {  // select only elements with the prop&value

				Pattern pattern = Pattern.compile(valueRegex);

				for (Element element : allElements) {

					String value = element.getProp(propName);

					if (value != null && pattern.matcher(value).matches()) {

						filteredElements.add(element);

					}

				}

			} else { // select only elements with the prop

				for (Element element : allElements) {

					if (element.getProps().containsKey(propName)) {

						filteredElements.add(element);

					}

				}

			}

			allElements = filteredElements;

		}

		if (debug >= 2) Log.finer(" prop&value step result: "+allElements.size());

		return allElements;

	}

	@Override

	public Query newQuery() {

		return new URSQuery();

	}

	@Override

	public boolean hasIndexes(CorpusBuild corpus) {

		return URSCorpora.isAnnotationStructureReady(corpus);

	}

	@Override

	public String getValueForProperty(Match match, SearchEngineProperty property) {

		// TODO Auto-generated method stub

		return null;

	}

	@Override

	public List<String> getValuesForProperty(Match match, SearchEngineProperty property) {

		// TODO Auto-generated method stub

		return null;

	}

}

package org.txm.annotation.urs.search;

import org.txm.objects.Match2P;

public class URSMatch extends Match2P {

	public URSMatch(int start, int end) {

		super(start, end);

	}

}

package org.txm.annotation.urs.search;

import org.txm.Toolbox;

import org.txm.core.engines.EngineType;

import org.txm.searchengine.core.Query;

import org.txm.searchengine.core.SearchEngine;

/**

 * 

 * Simple implementation of URS query in the "TYPE@PROPERTY=REGEX" form

 * 

 * @author mdecorde

 *

 */

public class URSQuery implements Query {

	String query = ""; //$NON-NLS-1$

	@Override

	public String getQueryString() {

		return query;

	}

	@Override

	public boolean isEmpty() {

		return query == null || query.isEmpty();

	}

	@Override

	public SearchEngine getSearchEngine() {

		return (SearchEngine) Toolbox.getEngineManager(EngineType.SEARCH).getEngine("URS"); //$NON-NLS-1$

	}

	@Override

	public Query setQuery(String rawQuery) {

		query = rawQuery;

		return this;

	}

	@Override

	public Query fixQuery() {

		return this;

	}

	@Override

	public String toString() {

		return query;

	}

	@Override

	public boolean equals(Query q) {

		return this.getClass().equals(q.getClass()) && this.getQueryString().equals(q.getQueryString());

	}

}

package org.txm.annotation.urs.search;

import java.util.ArrayList;

import java.util.List;

import org.txm.objects.Match;

import org.txm.searchengine.core.Query;

import org.txm.searchengine.core.Selection;

public class URSSelection extends Selection {

	ArrayList<? extends Match> matches;

	Query query;

	public URSSelection(Query query, ArrayList<URSMatch> matches2) {

		this.query = query;

		matches = matches2;

	}

	@Override

	public List<? extends Match> getMatches() throws Exception {

		return matches;

	}

	@Override

	public List<? extends Match> getMatches(int from, int to) throws Exception {

		if (to > matches.size()) to = matches.size();

		return matches.subList(from, to + 1); // +1 because Match.getMatches is start-end inclusive and List.subList is start inclusif and end exclusif

	}

	@Override

	public int getNMatch() throws Exception {

		return matches.size();

	}

	@Override

	public Query getQuery() {

		return query;

	}

	@Override

	public boolean isTargetUsed() throws Exception {

		return false;

	}

	@Override

	public void drop() throws Exception {

		// TODO Auto-generated method stub

	}

	@Override

	public boolean delete(int iMatch) {

		if (iMatch < 0) return false;

		if (iMatch >= matches.size()) return false;

		return matches.remove(iMatch) != null;

	}

	@Override

	public boolean delete(Match match) {

		return matches.remove(match);

	}

	@Override

	public boolean delete(ArrayList<Match> matchesToRemove) {

		return matches.removeAll(matchesToRemove);

	}

}

import org.txm.objects.CorpusBuild;

	private static final HashMap<CorpusBuild, Corpus> corpora = new HashMap<CorpusBuild, Corpus>();

	private static final HashMap<CorpusBuild, Vue> vues = new HashMap<CorpusBuild, Vue>();

	public static Corpus getCorpus(CorpusBuild mcorpus) {

		mcorpus = mcorpus.getRootCorpusBuild(); // ensure this is the root CorpusBuild

		File fichierVue = new File(mcorpus.getProjectDirectory(), "analec/"+mcorpus.getID()+".ecv"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

	public static boolean isAnnotationStructureReady(CorpusBuild mcorpus) {

		mcorpus = mcorpus.getRootCorpusBuild(); // ensure this is the root CorpusBuild

		if (URSCorpora.corpora.containsKey(mcorpus)) {

			return !URSCorpora.corpora.get(mcorpus).getStructure().isVide();

			File fichierCorpus = new File(mcorpus.getProjectDirectory(), "analec/"+mcorpus.getID()+".ec"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

				return !getCorpus(mcorpus).getStructure().isVide();

	public static Vue getVue(CorpusBuild mcorpus) {

		mcorpus = mcorpus.getRootCorpusBuild(); // ensure this is the root CorpusBuild

		if (!vues.containsKey(mcorpus)) {

			if (!corpora.containsKey(mcorpus)) {

				getCorpus(mcorpus);

			Corpus corpus = getCorpus(mcorpus);

			vues.put(mcorpus, vue);

		return vues.get(mcorpus);

	/**

	 * Save the associated AnalecCorpus

	 * @param mcorpus

	 * @return true if the annotations have been saved

	 */

	public static boolean saveCorpus(CorpusBuild mcorpus) {

		mcorpus = mcorpus.getRootCorpusBuild(); // ensure this is the root CorpusBuild

		for (CorpusBuild mcorpus : corpora.keySet()) {

		for (CorpusBuild mcorpus : corpora.keySet()) {

	public static void removeCorpus(CorpusBuild mcorpus) {

		mcorpus = mcorpus.getRootCorpusBuild(); // ensure this is the root CorpusBuild

	public static void revert(CorpusBuild mcorpus) {

		mcorpus = mcorpus.getRootCorpusBuild(); // ensure this is the root CorpusBuild

		corpora.remove(mcorpus);

		vues.remove(mcorpus);

		mcorpus.setIsModified(false);

		if (r instanceof CorpusBuild && "clean".equals(state)) { // $NON-NLS

			CorpusBuild mcorpus = (CorpusBuild)r;

			mcorpus = mcorpus.getRootCorpusBuild(); // ensure this is the root CorpusBuild

			File fichierVue = new File(mcorpus.getProjectDirectory(), "analec/"+mcorpus.getID()+".ecv"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

				for (TXMResult c : project.getChildren(CorpusBuild.class)) {

					URSCorpora.saveCorpus((CorpusBuild)c);

import java.util.List;