Laboratoire ICAR » Plateforme TXM

package org.txm.function.tigersearch;

import ims.tiger.corpus.NT_Node;

import ims.tiger.corpus.Node;

import ims.tiger.corpus.Sentence;

import ims.tiger.corpus.T_Node;

import ims.tiger.gui.tigergraphviewer.draw.Display_Sentence;

import ims.tiger.gui.tigergraphviewer.forest.ResultForest;

import ims.tiger.query.api.MatchResult;

import ims.tiger.query.internalapi.InternalCorpusQueryManager;

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.regex.Pattern;

import org.txm.Toolbox;

import org.txm.index.core.functions.Index;

import org.txm.index.core.functions.Line;

import org.txm.searchengine.cqp.AbstractCqiClient;

import org.txm.searchengine.cqp.CQPEngine;

import org.txm.searchengine.cqp.ICqiClient;

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

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

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

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

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

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

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

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

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

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

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

import org.txm.searchengine.cqp.serverException.CqiServerError;

import org.txm.searchengine.ts.TSCorpus;

import org.txm.searchengine.ts.TSCorpusManager;

import org.txm.searchengine.ts.TSMatch;

import org.txm.searchengine.ts.TSResult;

import org.txm.utils.logger.Log;

public class TSIndex extends Index {

	public TSIndex(Corpus corpus, List<Property> props)

			throws CqiClientException, IOException, CqiServerError {

		super(corpus, new Query("[]"), props);

	}

	public TSIndex(Corpus corpus, Query query, List<Property> props)

			throws CqiClientException, IOException, CqiServerError {

		super(corpus, query, props);

	}

	public TSIndex(Partition partition, Query query, List<Property> props)

			throws CqiClientException, IOException, CqiServerError {

		super(partition, query, props);

	}

	boolean isTIgerInitialized = false;

	private TSCorpus tscorpus;

	private TSResult tsresult;

	private boolean initTIGERSearch() {

		if (isTIgerInitialized) return isTIgerInitialized;

		String id = getCorpus().getMainCorpus().getName();

		File configfile = new File(getCorpus().getBaseDirectory(),"tiger/tigersearch.logprop");

		File registrydir = new File(getCorpus().getBaseDirectory(), "tiger");

		TSCorpusManager manager = new TSCorpusManager(registrydir, configfile);

		if (manager.isInitialized()) {

			tscorpus = manager.getCorpus(id);

			if (tscorpus == null) {

				System.out.println("TIGERSearch corpus not found in "+registrydir);

				isTIgerInitialized = false;

			}

			isTIgerInitialized = true;

		}

		return isTIgerInitialized;

	}

	@Override

	/**

	 * count tokens.

	 *

	 * @param corp the corp

	 * @return true, if successful

	 * @throws CqiClientException 

	 * @throws CqiServerError 

	 * @throws IOException 

	 */

	protected boolean scanCorpus(Corpus corp) throws CqiClientException, IOException, CqiServerError {

		if (!initTIGERSearch()) return false;

		// get the cqp result of the query

		//	long time = System.currentTimeMillis();

		//		QueryResult result = corp.query(getQuery(), "index", true); //$NON-NLS-1$

		boolean isTargetUsed = false;//Toolbox.getCqiClient().subCorpusHasField(result.getQualifiedCqpId(), ICqiClient.CQI_CONST_FIELD_TARGET);

		// System.out.println("nLines : "+nLines);

		List<Match> matches;

		try {

			matches = getMatchesFromTSQuery(corp);

		} catch (Exception e1) {

			System.out.println("Error while queing TIGERSearch: "+e1);

			e1.printStackTrace();

			return false;

		}

		int nbresults = matches.size();

		if (nbresults == 0) {

			return false;

		}

		this.nLines += nbresults; // get number of tokens

		// count matches

		// time = System.currentTimeMillis();

		List<Integer> allpositions = new ArrayList<Integer>();

		for (int j = 0; j < nbresults; j++) {

			Match match = matches.get(j);

			// beginingOfKeywordsPositions.add(match.getStart()); // get the

			// first index

			// lengthOfKeywords.add(match.size());// get the last index

			if (isTargetUsed) {

				allpositions.add(match.getTarget());

			} else {

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

					allpositions.add(i);

			}

		}

		int[] allpositionsarray = new int[allpositions.size()];

		int pcount = 0;

		for (int p : allpositions)

			allpositionsarray[pcount++] = p;

		// time = System.currentTimeMillis();

		HashMap<Property, int[]> propsId = new HashMap<Property, int[]>();

		for (Property property : props) {

			try {

				if (property instanceof StructuralUnitProperty) {

					int[] structs = CorpusManager.getCorpusManager()

							.getCqiClient().cpos2Struc(

									property.getQualifiedName(),

									allpositionsarray);

					propsId.put(property, structs);

				} else {

					int[] indices = CorpusManager.getCorpusManager()

							.getCqiClient().cpos2Id(

									property.getQualifiedName(),

									allpositionsarray);

					propsId.put(property, indices);

				}

			} catch (Exception e) {

				System.out.println("Error while properties projection: "+e);

				Log.printStackTrace(e);

				return false;

			}

		}

		// System.out.println("Time recup indices "+(System.currentTimeMillis()-time));

		int currentIndex = 0;

		// time = System.currentTimeMillis();

		for (int i = 0; i < nbresults; i++) {

			Line line = new Line();

			Match match = matches.get(i);

			int size = match.size();

			if (isTargetUsed) size = 1;

			for (int p = 0; p < props.size(); p++) {

				Property property = props.get(p);

				int[] allprosids = propsId.get(property);

				int[] ids = new int[size];

				System.arraycopy(allprosids, currentIndex, ids, 0, size);

				line.putIds(property, ids);

			}

			currentIndex += size;

			String signature = line.getSignature();

			if (counts.containsKey(signature)) // if the counts contains the

				// signature, increment its

				// corresponding value

			{

				while (counts.get(signature).size() <= currentpartid)

					counts.get(signature).add(0);

				int c = counts.get(signature).get(currentpartid) + 1;

				counts.get(signature).set(currentpartid, c);

			} else // else initialize count of the signature to 1

			{

				// System.out.println("add new sign "+signature+" of line "+line.toString());

				ArrayList<Integer> tmp = new ArrayList<Integer>();

				for (int j = 0; j < currentpartid + 1; j++)

					tmp.add(0);

				counts.put(signature, tmp);

				counts.get(signature).set(currentpartid, 1);

				lines.add(line);

			}

		}

		// System.out.println("Time count lines "+(System.currentTimeMillis()-time));

		// System.out.println("took "+(System.currentTimeMillis()-time));

		return true;

	}

	private List<Match> getMatchesFromTSQuery(Corpus corp) throws Exception {

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

		tsresult = tscorpus.query(query.toString());

		boolean debug = false;

		ResultForest forest = tsresult.getForest();

		MatchResult result = tsresult.getMatchResult();

		int var_ok = 0;

		String label = "@|pivot";

		Pattern p = Pattern.compile(label);

		for (String var : result.getVariableNames()) {

			if (p.matcher(var).matches()) var_ok++;

		}

		if (var_ok == 0) {

			System.out.println("** Error in TSIndex: no label '@' or 'pivot' found in TIGERSearch query. Aborting.");

			return matches; 

		} else if (var_ok > 1) {

			System.out.println("** Error in TSIndex: too many labels '@' or 'pivot' found in TIGERSearch query. Aborting.");

			return matches; 

		}

		InternalCorpusQueryManager manager = tsresult.getManager();

		//		Display_Sentence match = null;

		//		

		//		if (forest.isNextMatch()) {

		//			match = forest.nextMatch();

		//		} else {

		//			match = null;

		//		}

		HashSet<String> matchingTnodesID = new HashSet<String>();

		String EDITIONID = "editionId";

		int size = forest.getForestSize();

		for ( int match_no = 0 ; match_no < size ; match_no++) {

			if (debug) System.out.println("Match "+match_no);

			int sentno = result.getSentenceNumberAt(match_no);

			Sentence sentence = manager.getSentence(sentno);

			result.orderSentenceSubmatches(sentno); 

			int n = result.getSentenceSubmatchSize(sentno);

			for (int iSubMatch=0; iSubMatch<n; iSubMatch++) {

				if (debug) System.out.println(" Sub "+iSubMatch);

				int[] var_values = result.getSentenceSubmatchAt(sentno, iSubMatch);

				int value;

				for (int j=0; j<var_values.length; j++) {

					if (debug) System.out.println("  Var "+j+" name="+result.getVariableName(j));

					value = var_values[j];

					if (value>=0) {

						String var_name = result.getVariableName(j);

						Node referred = sentence.getNode(value);

						if (p.matcher(var_name).matches()) {

							if (referred instanceof T_Node) {

								if (debug) System.out.println("    Node: "+referred.getFeature(EDITIONID));

								matchingTnodesID.add(referred.getFeature(EDITIONID));

							} else if (referred instanceof NT_Node) {

								for (T_Node c : getTerminals((NT_Node) referred, sentence)) {

									matchingTnodesID.add(c.getFeature(EDITIONID));

								}

							}

						}

					}

				}

			}

		}

		//		while (match != null) {

		//			if (debug) System.out.println("Match: "+forest.getCurrentMatchNumber()+" Nsub="+forest.getSubMatchesSize());

		//			Display_Sentence sub = null;

		//			int[] var_values = match.getSentenceSubmatchAt(sentno,i);

		//			

		//			sub = match;

		//			int nlabel;

		//			while (sub != null) {

		//				if (debug) System.out.println(" Sub: "+forest.getCurrentSubMatchNumber());

		//				Node matchingNode = sub.getMatchSubgraphNode();

		//				//if (debug) System.out.println(matchingNode.getIncomingEdgeLabel());

		//				if (matchingNode instanceof T_Node) {

		//					T_Node node = (T_Node)matchingNode;

		//					if (debug) System.out.println("  T node: "+node.getFeature(EDITIONID)+" "+node.getFeature("word"));

		//					matchingTnodesID.add(node.getFeature(EDITIONID));

		//				} else if (matchingNode instanceof NT_Node) {

		//					NT_Node ntnode = (NT_Node)matchingNode;

		//					if (debug) System.out.println("  NT node: "+ntnode.getChilds());

		//					for (T_Node node : getTerminals(ntnode, sub)) {

		//						if (debug) System.out.println("   T node: "+node.getFeature(EDITIONID)+" "+node.getFeature("word"));

		//						matchingTnodesID.add(node.getFeature(EDITIONID));

		//					}

		//				}

		//

		//				if (forest.isNextSubMatch()) {

		//					sub = forest.nextSubMatch();

		//				} else {

		//					sub = null;

		//				}

		//			}

		//			

		//			if (forest.isNextMatch()) {

		//				match = forest.nextMatch();

		//			} else {

		//				match = null;

		//			}

		//		}

		HashSet<String> matchingTnodesIDFiltered = new HashSet<String>();

		for (String s : matchingTnodesID) {

			if (s == null || s.length() == 0 || s.endsWith("_dupl")) {

			} else {

				matchingTnodesIDFiltered.add(s);

			}

		}

		if (debug) System.out.println("Matching ids: "+matchingTnodesIDFiltered);

		String[] strings = new String[matchingTnodesIDFiltered.size()];

		int i = 0;

		for (String s : matchingTnodesIDFiltered) strings[i++] = s;

		matchingTnodesIDFiltered = null;

		matches = buildMatches_CQI(strings);

		strings = null;

		// one word per match ! the word is inside one of the CQP (sub-)Corpus matches

		List<Match> finalMatches = new ArrayList<Match>();

		List<Match> corpusMatches = corp.getMatches();

		int iCorpusStart = 0;

		for (int iMatch = 0 ; iMatch < matches.size() ; iMatch++) {

			Match m1 = matches.get(iMatch);

			for (int iCorpus = iCorpusStart ; iCorpus < corpusMatches.size() ; iCorpus++) {

				Match m2 = corpusMatches.get(iCorpus);

				if (m2.getStart() <= m1.getStart() && m1.getEnd() <= m2.getEnd()) {

					finalMatches.add(m1);

					iCorpusStart = iCorpus; // optimizing ! \o/

					break;

				}

			}

		}

		matches = null;

		corpusMatches = null;

		return finalMatches;

	}

	private ArrayList<Match> buildMatches_CQI(String[] strings) throws CqiClientException, IOException, CqiServerError {

		boolean debug = false;

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

		AbstractCqiClient CQI = CQPEngine.getCqiClient();

		Property idProperty = getCorpus().getProperty("id");

		if (debug) System.out.println("Call CQI.str2Id with strings.len="+strings.length);

		if (debug) System.out.println(Arrays.toString(strings));

		if (debug) System.out.flush();

		int[] ids = CQI.str2Id(idProperty.getQualifiedName(), strings);

		if (debug) System.out.println("Call CQI.idList2Cpos with strings.len="+ids.length);

		if (debug) System.out.println(Arrays.toString(ids));

		if (debug) System.out.flush();

		HashSet<Integer> positionsSet = new HashSet<Integer>();

		for (int id : ids) {

			int[] positions = CQI.id2Cpos(idProperty.getQualifiedName(), id);

			for( int p : positions) positionsSet.add(p);

		}

		int[] positions = new int[positionsSet.size()];

		int i = 0;

		for (int p : positionsSet) positions[i++] = p;

		positionsSet = null;

		Arrays.sort(positions);

		if (debug) System.out.println("Positions: "+Arrays.toString(positions));

		for (int p : positions) matches.add(new Match(p, p, -1));

		//build matches and regroups matches

		//		int previous = -999;

		//		int start = -1, end = -1, target = -1;

		//		for (int p : positions) {

		//			//System.out.println("P="+p+" start="+start+" end="+end+" target="+target+" Prev="+previous);

		//			if (p - previous > 1) {

		//				if (start >= 0) {

		//					matches.add(new Match(start, end, target));

		//				}

		//				start = p;

		//			}

		//			end = p;

		//			previous = p;

		//		}

		//		System.out.println(matches);

		return matches;

	}

	protected static ArrayList<T_Node> EMPTYTERMINALS = new ArrayList<T_Node>();

	public static ArrayList<T_Node> getTerminals(NT_Node ntnode, Sentence sub) {

		if (ntnode.getChilds().size() == 0) return EMPTYTERMINALS;

		ArrayList<T_Node> terminals = new ArrayList<T_Node>();

		for (Object o : ntnode.getChilds()) {

			int n = (Integer)o;

			Node node = sub.getNode(n);

			if (node instanceof T_Node) {

				terminals.add((T_Node)node);

			} else if (node instanceof NT_Node) {

				terminals.addAll(getTerminals((NT_Node)node, sub));

			}

		}

		return terminals;

	}

}

package org.txm.function.tigersearch;

import java.io.File;

import java.util.Arrays;

import java.util.List;

import org.eclipse.core.runtime.IAdaptable;

import org.eclipse.jface.resource.ImageDescriptor;

import org.eclipse.ui.model.IWorkbenchAdapter;

import org.eclipse.ui.plugin.AbstractUIPlugin;

import org.txm.functions.ProgressWatcher;

import org.txm.functions.TXMCommand;

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

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

import org.txm.searchengine.ts.TSCorpus;

import org.txm.searchengine.ts.TSCorpusManager;

import org.txm.searchengine.ts.TSMatch;

import org.txm.searchengine.ts.TSResult;

import org.txm.tigersearch.commands.ComputeTIGERSearch;

import org.txm.utils.logger.Log;

public class TIGERSearch extends TXMCommand implements IAdaptable {

	TSCorpusManager manager;

	TSCorpus tscorpus;

	boolean ready = false;

	private TSResult tsresult;

	String T, NT;

	private MainCorpus corpus;

	private String query;

	public TIGERSearch(Corpus corpus) {

		this.corpus = corpus.getMainCorpus();

		String id = corpus.getName();

		File configfile = new File(corpus.getBaseDirectory(),"tiger/tigersearch.logprop");

		File registrydir = new File(corpus.getBaseDirectory(), "tiger");

		File tscorpusdir = new File(corpus.getBaseDirectory(), "tiger/"+id);

		if (!tscorpusdir.exists()) {

			System.out.println("Error: can't find corpus directory: "+tscorpusdir);

			return;

		}

		TSCorpusManager manager = new TSCorpusManager(registrydir, configfile);

		if (manager.isInitialized()) {

			tscorpus = manager.getCorpus(id);

			if (tscorpus == null) {

				System.out.println("TIGERSearch corpus not found in "+registrydir);

				ready = false;

				return;

			}

			ready = true;

		}

	}

	public boolean compute(String query) throws Exception {

		if (tscorpus == null) return false;

		tsresult = null;

		if (query.length() == 0) {

			return false;

		}

		this.query = query;

		tsresult = tscorpus.query(query);

		tsresult.getFirst();

		return true;

	}

	public boolean isComputed() {

		return tsresult != null;

	}

	public boolean isDrawn() {

		return tsresult!= null && T != null && NT != null;

	}

	public boolean toSVG(File svgFile, int sent, int sub, String T, String NT) {

		if (tsresult == null) return false; // no result

		this.T = T;

		this.NT = NT;

		tsresult.setDisplayProperties(Arrays.asList(T), NT);

		try {

			// iterate to the sub th subgraph

			TSMatch match = tsresult.getMatch(sent);

			match.setSubGraph(sub-1);

			svgFile.delete();

			match.toSVGFile(svgFile);

			if (!svgFile.exists()) {

				System.out.println("Fail to render SVG match for sent="+sent+" and sub="+sub);

				return false;

			}

		} catch(Exception e) {

			Log.printStackTrace(e);

		}

		return true;

	}

	public String[] getTProperties() {

		if (tscorpus == null) return new String[0];

		List<String> tFeatures = tscorpus.getTFeatures();

		return tFeatures.toArray(new String[tFeatures.size()]);

	}

	public String[] getNTProperties() {

		if (tscorpus == null) return new String[0];

		List<String> ntFeatures = tscorpus.getNTFeatures();

		return ntFeatures.toArray(new String[ntFeatures.size()]);

	}

	public Corpus getParent() {

		return corpus;

	}

	public boolean isReady() {

		return ready;

	}

	public String getT() {

		return T;

	}

	public String getNT() {

		return NT;

	}

	public int getNSentences() {

		if (tsresult == null) return 0;

		return tsresult.getNumberOfMatch();

	}

	public int getNSubGraph() {

		if (tsresult == null) return 0;

		return tsresult.getCurrentMatch().getNumberOfSubGraph();

	}

	public int getSent() {

		if (tsresult == null) return 0;

		return tsresult.getCurrentMatchNo();

	}

	public int getSub() {

		if (tsresult == null) return 0;

		return tsresult.getCurrentMatch().getCurrentSubMatchNo();

	}

	/** The WordCloud adapter. */

	private static IWorkbenchAdapter tsAdapter = new IWorkbenchAdapter() {

		@Override

		public Object[] getChildren(Object o) {

			return new Object[0];

		}

		@Override

		public ImageDescriptor getImageDescriptor(Object object) {

			return AbstractUIPlugin.imageDescriptorFromPlugin("TIGERSearchRCP", "icons/functions/TS.png"); //$NON-NLS //$NON-NLS-1$

		}

		@Override

		public String getLabel(Object o) {

			String q = ((TIGERSearch) o).getQuery();

			return q.substring(0, Math.min(10, q.length())).replaceAll("\n", "")+"...";

		}

		@Override

		public Object getParent(Object o) {

			return ((TIGERSearch) o).getParent();

		}

	};

	@Override

	public Object getAdapter(@SuppressWarnings("rawtypes") Class adapterType) {

		if (adapterType == IWorkbenchAdapter.class)

			return tsAdapter;

		return null;

	}

	public String getQuery() {

		return query;

	}

	public String toString() {

		return query.substring(0, Math.min(20,  query.length())).replaceAll("\n", " ")+" T: "+T+" NT: "+NT;

	}

	public boolean openEditor() {

		ComputeTIGERSearch.openEditor(this);

		return true;

	}

	@Override

	public boolean toTxt(File outfile, String encoding, String colseparator,

			String txtseparator) throws Exception {

		return tsresult.toXml(outfile);

	}

	@Override

	public void clean() {

	}

	@Override

	public boolean delete() {

		return corpus.removeResult(this);

	}

	/**

	 * 

	 * @return the array of extensions to show in the FileDialog SWT widget

	 */

	public String[] getExportTXTExtensions() {

		return new String[]{"*.xml"};

	}

	@Override

	public boolean compute(ProgressWatcher watcher) throws Exception {

		// TODO Auto-generated method stub

		return false;

	}

	@Override

	public String getName() {

		return query;

	}

	@Override

	public String getSimpleName() {

		return query;

	}

	@Override

	public String getDetails() {

		return query;

	}

}

// Copyright © 2010-2013 ENS de Lyon.

// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of

// Lyon 2, University of Franche-Comté, University of Nice

// Sophia Antipolis, University of Paris 3.

// 

// The TXM platform is free software: you can redistribute it

// and/or modify it under the terms of the GNU General Public

// License as published by the Free Software Foundation,

// either version 2 of the License, or (at your option) any

// later version.

// 

// The TXM platform is distributed in the hope that it will be

// useful, but WITHOUT ANY WARRANTY; without even the implied

// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

// PURPOSE. See the GNU General Public License for more

// details.

// 

// You should have received a copy of the GNU General

// Public License along with the TXM platform. If not, see

// http://www.gnu.org/licenses.

// 

// 

// 

// $LastChangedDate:$

// $LastChangedRevision:$

// $LastChangedBy:$ 

//

package org.txm.searchengine.ts;

import ims.tiger.corpus.Header;

import ims.tiger.export.ExportException;

import ims.tiger.export.ExportStopException;

import ims.tiger.export.QueryToSvg;

import ims.tiger.gui.tigergraphviewer.forest.ResultForest;

import ims.tiger.query.api.MatchResult;

import ims.tiger.query.api.QueryEvaluationException;

import ims.tiger.query.api.QueryFilterException;

import ims.tiger.query.api.QueryIndexException;

import ims.tiger.query.api.QueryNormalizationException;

import ims.tiger.query.api.QueryOptimizationException;

import ims.tiger.query.internalapi.InternalCorpusQueryManager;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.UnsupportedEncodingException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import javax.xml.parsers.ParserConfigurationException;

import javax.xml.transform.TransformerException;

import org.txm.core.messages.TXMCoreMessages;

import org.txm.core.preferences.TBXPreferences;

import org.txm.core.preferences.TXMPreferences;

import org.txm.export.ts.ConcordanceBlocks;

import org.txm.export.ts.MatchInject;

import org.txm.export.ts.PunctInject;

import org.txm.importer.ApplyXsl2;

import org.txm.utils.logger.Log;

import org.txm.utils.xml.DomUtils;

import org.w3c.dom.Document;

import org.xml.sax.SAXException;

// TODO: Auto-generated Javadoc

/**

 * The Class TSResult.

 */

public class TSResult {

	/** The result. */

	MatchResult result;

	/** The forest. */

	ResultForest forest;

	/** The header. */

	Header header;

	/** The ts corpus. */

	TSCorpus tsCorpus;

	/** The matches. */

	TSMatch[] matches;

	/** The current match. */

	int currentMatchNo = 0;

	TSMatch currentMatch;

	/** The query. */

	private String query;

	/** The manager. */

	private InternalCorpusQueryManager manager;

	/** The corpus. */

	//private TSCorpus corpus;

	/** The tsquerytosvg. */

	QueryToSvg tsquerytosvg = null;

	/**

	 * Instantiates a new tS result.

	 *

	 * @param query the query

	 * @param tsCorpus the ts corpus

	 * @throws QueryFilterException 

	 * @throws QueryOptimizationException 

	 * @throws QueryIndexException 

	 * @throws QueryEvaluationException 

	 * @throws QueryNormalizationException 

	 * @throws Exception 

	 */

	public TSResult(String query, TSCorpus tsCorpus) throws Exception {

		this.query = query;

		this.manager = tsCorpus.manager;

		//this.corpus = tsCorpus;

		this.tsCorpus = tsCorpus;

		result = tsCorpus.manager.processQuery(query);

		forest = new ResultForest(result, tsCorpus.manager);

		header = forest.getHeader();

		matches = new TSMatch[result.size()];

		tsquerytosvg = new QueryToSvg(manager, result, forest, header, tsCorpus.config);

	}

	public ResultForest getForest() {

		return forest;

	}

	public MatchResult getMatchResult() {

		return result;

	}

	public InternalCorpusQueryManager getManager() {

		return manager;

	}

	/**

	 * Gets the number of match.

	 *

	 * @return the number of match

	 */

	public int getNumberOfMatch()

	{

		return result.size();

	}

	/**

	 * return the no of match, begins with 1.

	 *

	 * @return the current match no

	 */

	public int getCurrentMatchNo() {

		return currentMatchNo;

	}

	/**

	 * return the no of match, begins with 1.

	 *

	 * @return the current match no

	 */

	public TSMatch getCurrentMatch() {

		return currentMatch;

	}

	/**

	 * return the no of match, begins with 1.

	 *

	 * @return the current sentence no

	 */

	public int getCurrentSentenceNo() {

		System.out.println(TXMCoreMessages.TSResult_0+this.getNumberOfMatch());

		System.out.println("current match "+this.getCurrentMatchNo()); //$NON-NLS-1$

		System.out.println(TXMCoreMessages.TSResult_2+this.getCurrentMatch().getNumberOfSubGraph());

		System.out.println("current sub graph "+this.getCurrentMatch().getCurrentSubMatchNo()); //$NON-NLS-1$

		return result.getSentenceNumberAt(this.currentMatchNo); // + 1 ?

	}

	/**

	 * Gets the match.

	 *

	 * @param matchNo the no

	 * @return the match

	 */

	public TSMatch getMatch(int matchNo)

	{

		if (matches[matchNo] == null) {

			TSMatch m = new TSMatch(matchNo, this.tsquerytosvg, this);

			matches[matchNo] = m;

		}

		return matches[matchNo] ;

	}

	public void setDisplayProperties(List<String> tprops, String feature) {

		tsCorpus.setDisplayProperties(this.header, tprops, feature);

	}

	/**

	 * Gets the first.

	 *

	 * @return the first

	 */

	public TSMatch getFirst()

	{

		if (result.size() > 0) {

			currentMatchNo = 0;

			currentMatch = getMatch(0);

			return currentMatch;

		} else {

			return null;

		}

	}

	/**

	 * Gets the last.

	 *

	 * @return the last

	 */

	public TSMatch getLast()

	{

		if (result.size() > 0) {

			currentMatchNo = result.size() -1;

			currentMatch = getMatch(result.size() -1);

			return currentMatch;

		} else {

			return null;

		}

	}

	/**

	 * Gets the next.

	 *

	 * @return the next

	 */

	public TSMatch getNext()

	{

		int next = currentMatchNo + 1;

		if (result.size() > next) {

			currentMatchNo = next;

			currentMatch = getMatch(next);

			return currentMatch;

		} else {

			return null;

		}

	}

	/**

	 * Gets the previous.

	 *

	 * @return the previous

	 */

	public TSMatch getPrevious()

	{

		int next = currentMatchNo - 1;

		if (next >= 0 && result.size() > 0) {

			currentMatchNo = next;

			currentMatch = getMatch(next);

			return currentMatch;

		} else {

			return null;

		}

	}

	public TSMatch setCurrentMatch(int graphNo) {

		currentMatch = this.getMatch(graphNo);

		currentMatchNo = graphNo;

		return currentMatch;

	}

	public boolean toXml(File outfile, File xmlFile, File xslFile) throws ExportException, ExportStopException, IOException, TransformerException

	{

		return toXml(outfile, xmlFile, xslFile, false, 30, new ArrayList<String>(), new ArrayList<String>());

	}

	public static String CONCSIMPLE = "concordance_simple"; //$NON-NLS-1$

	public static String CONCMOTPIVOT = "concordance_mot-pivot"; //$NON-NLS-1$

	public static String CONCBLOCKS = "concordance_blocks"; //$NON-NLS-1$

	public static String[] EXPORTMETHODS = {CONCSIMPLE, CONCMOTPIVOT, CONCBLOCKS};

	public boolean toConcordance(File csvFile, String method, int cx, ArrayList<String> ntTypes, ArrayList<String> tTypes, boolean punct) throws Exception

	{

		if (!Arrays.asList(EXPORTMETHODS).contains(method)) {

			Log.severe(TXMCoreMessages.TSResult_7+method+TXMCoreMessages.TSResult_8+Arrays.toString(EXPORTMETHODS));

			return false;

		}

		File xmlFile = File.createTempFile(csvFile.getName(), "EXPORTBRUT.xml", csvFile.getParentFile()); //$NON-NLS-1$

		boolean rez = false;

		if (punct) { 

			// export match

			//System.out.println("save matches in "+xmlFile);

			this.toXml(xmlFile, false, true, false, false, true, false, 0);

			//FileCopy.copy(xmlFile, new File(xmlFile.getParentFile(), "EXPORTBRUT.xml"));

			// merge with TigerXMLPOSPNC

			File tmp = File.createTempFile("txm", "AFTERMINJECT.xml", xmlFile.getParentFile()); //$NON-NLS-1$ //$NON-NLS-2$

			File tigerXml = new File(tsCorpus.tsmanager.getRegistryPath(), "TigerPnc.xml"); //$NON-NLS-1$

			//System.out.println("TIGER XML: "+tigerXml);

			if (!tigerXml.exists()) {

				System.out.println(TXMCoreMessages.TSResult_13+tigerXml.getAbsolutePath());

				return false;

			}

			//System.out.println("Match inject: in "+tmp);

			new MatchInject().script(tigerXml, xmlFile, tmp);

			xmlFile.delete();

			tmp.renameTo(xmlFile);

			//FileCopy.copy(xmlFile, new File(xmlFile.getParentFile(), "AFTERMINJECT.xml"));

		} else {

			this.toXml(xmlFile); // export match + corpus

			//FileCopy.copy(xmlFile, new File(xmlFile.getParentFile(), "FULLEXPORT.xml"));

		}

		if (!xmlFile.exists()) { System.out.println(TXMCoreMessages.TSResult_14); return false;}

		if (method.equals("concordance_blocks")) { //$NON-NLS-1$

			ConcordanceBlocks builder = new ConcordanceBlocks();

			rez = builder.process(xmlFile, csvFile, cx, ntTypes, tTypes);

		} else { // XSL method

			File xslDir = new File(TXMPreferences.getString(TBXPreferences.USER_TXM_HOME, TBXPreferences.PREFERENCES_NODE), "xsl"); //$NON-NLS-1$

			File xslFile = new File(xslDir, method+".xsl"); //$NON-NLS-1$

			if (!xslFile.exists()) {

				Log.severe(TXMCoreMessages.TSResult_7+xslFile);

				return false;

			}

			rez = toXml(csvFile, xmlFile, xslFile, punct, cx, ntTypes, tTypes);

		}

		xmlFile.delete(); // no more needed

		return rez;

	}

	public boolean toXml(File outfile) throws ExportException, ExportStopException

	{

		toXml(outfile, true, true);

		return true;

	}

	public boolean toXml(File outfile, boolean includeNonMatch, boolean includeMatch, 

			boolean includeXmlHeader, boolean includeXMLSentenceStructure, 

			boolean includeXMLMatchInformation, boolean refineSchema, int referSchema) throws ExportException, ExportStopException

			{

		this.tsCorpus.exporter.setConfiguration(includeXmlHeader,

				includeXMLSentenceStructure,

				includeXMLMatchInformation,

				refineSchema,

				referSchema);

		this.tsCorpus.exporter.saveMatchAsXML(result, outfile, includeNonMatch, includeMatch);

		return true;

			}

	public boolean toXml(File outfile, boolean includeNonMatch, boolean includeMatch) throws ExportException, ExportStopException

	{

		boolean includeXmlHeader = true;

		boolean includeXMLSentenceStructure = true;

		boolean includeXMLMatchInformation = true;

		boolean refineSchema = false;

		int referSchema = 0;

		return toXml(outfile, includeNonMatch, includeMatch, includeXmlHeader, includeXMLSentenceStructure, includeXMLMatchInformation, refineSchema, referSchema);

	}

	@Deprecated

	private void injectPunct(File xmlfile)

	{

		System.out.println(TXMCoreMessages.TSResult_18);

		String corpus = this.tsCorpus.id.toUpperCase();

		try {

			Document dom = DomUtils.load(xmlfile);

			//System.out.println("Getting words of "+corpus);

			Object words = PunctInject.getWords(corpus, ""); //$NON-NLS-1$

			//			int i = 0;

			//			for(String[] word : (ArrayList<String[]>)words)

			//			{

			//				if(i++ % 10 == 0) System.out.println();

			//				System.out.print("[\""+word[0]+"\", \""+word[1].replace("\"", "\\\"")+"\"], ");

			//			}

			File outfile = File.createTempFile("punct", ".xml", xmlfile.getParentFile()); //$NON-NLS-1$ //$NON-NLS-2$

			//System.out.println("Processing "+xmlfile+" to "+outfile);

			Document doc = (Document) new PunctInject().process(dom, words);

			//System.out.println("Saving file");

			DomUtils.save(doc, outfile);

			//			FileCopy.copy(outfile, new File(outfile.getParentFile(), "afterinject.xml"));

			xmlfile.delete();

			outfile.renameTo(xmlfile);

		} catch (UnsupportedEncodingException e) {

			// TODO Auto-generated catch block

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

		} catch (FileNotFoundException e) {

			// TODO Auto-generated catch block

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

		} catch (ParserConfigurationException e) {

			// TODO Auto-generated catch block

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

		} catch (SAXException e) {

			// TODO Auto-generated catch block

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

		} catch (IOException e) {

			// TODO Auto-generated catch block

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

		}

	}

	public boolean toXml(File outFile, File xmlFile, File xslFile, boolean punct, int cxsize, ArrayList<String> ntTypes, ArrayList<String> tTypes) throws ExportException, ExportStopException, IOException, TransformerException

	{

		ApplyXsl2 xslProc = new ApplyXsl2(xslFile);

		xslProc.setParam("cx", cxsize); //$NON-NLS-1$

		xslProc.setParam("ntTypes", ntTypes.toString().replaceAll("[\\[\\],]", "")); // ["pos", "lem"] //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

		xslProc.setParam("tTypes", tTypes.toString().replaceAll("[\\[\\],]", "")); // ["truc", "machin"] //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

		if (xslProc.process(xmlFile, outFile)) {

			return outFile.exists();

		} else {

			return false;

		}

	}

}

package org.txm.searchengine.ts;

//Copyright © - ANR Textométrie - http://textometrie.ens-lyon.fr

//

//This file is part of the TXM platform.

//

//The TXM platform is free software: you can redistribute it and/or modif y

//it under the terms of the GNU General Public License as published by

//the Free Software Foundation, either version 3 of the License, or

//(at your option) any later version.

//

//The TXM platform is distributed in the hope that it will be useful,

//but WITHOUT ANY WARRANTY; without even the implied warranty of

//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

//GNU General Public License for more details.

//

//You should have received a copy of the GNU General Public License

//along with the TXM platform.  If not, see <http://www.gnu.org/licenses/>.

//

// @author Nicolas Mazziotta <nicolas.mazziotta -at- ulg.ac.be>

//

//$LastChangedDate: $

//$LastChangedRevision:  $

//$LastChangedBy: $ 

import java.io.File;

import org.apache.commons.cli.CommandLine;

import org.apache.commons.cli.CommandLineParser;

import org.apache.commons.cli.HelpFormatter;

import org.apache.commons.cli.Options;

import org.apache.commons.cli.ParseException;

import org.apache.commons.cli.PosixParser;

import org.txm.core.messages.TXMCoreMessages;

/**

 * CommandLine to execute TIGERSearch

 * 

 * @author Nicolas Mazziotta <nicolas.mazziotta -at- ulg.ac.be>

 *

 */

public class TSCmd {

	/**

	 * @param args

	 * @throws Exception 

	 */

	public static void main(String[] args) throws Exception {

		Options options = new Options();

		options.addOption("c", true, "config path (dflt: $HOME/TigerSearch/config/tigersearch.logprop)"); //$NON-NLS-1$ //$NON-NLS-2$

		options.addOption("r", true, "registry path (dflt: $HOME/TigerSearch/TIGERCorpora)"); //$NON-NLS-1$ //$NON-NLS-2$

		options.addOption("i", true, "corpus id (COMPULSORY)"); //$NON-NLS-1$ //$NON-NLS-2$

		options.addOption("q", true, "query string (dflt: [])"); //$NON-NLS-1$ //$NON-NLS-2$

		options.addOption("o", true, "output path (dflt: ."); //$NON-NLS-1$ //$NON-NLS-2$

		options.addOption("h", false, "print help and exit"); //$NON-NLS-1$ //$NON-NLS-2$

		CommandLineParser parser = new PosixParser();

		CommandLine cmd = null;

		HelpFormatter formatter = new HelpFormatter();

		try {

			cmd = parser.parse(options, args);

		} catch (ParseException e) {

			// TODO Auto-generated catch block

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

		}

		String homedir = System.getenv("HOME"); //$NON-NLS-1$

		File configdir = new File(homedir, "TigerSearch/config/tigersearch.logprop"); //$NON-NLS-1$

		File registrydir = new File(homedir, "TigerSearch/TIGERCorpora"); //$NON-NLS-1$

		String outdir = "."; //$NON-NLS-1$

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

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

		if (cmd.hasOption("h")) {  //$NON-NLS-1$

			formatter.printHelp( "TSCmd -i Corpus Id [OTHER OPTIONS]", options ); //$NON-NLS-1$

			return;

		}

		if (cmd.hasOption("c")) { configdir = new File(cmd.getOptionValue("c")); } //$NON-NLS-1$ //$NON-NLS-2$

		if (cmd.hasOption("r")) { registrydir = new File(cmd.getOptionValue("r")); } //$NON-NLS-1$ //$NON-NLS-2$

		if (cmd.hasOption("i")) { id = cmd.getOptionValue("i"); } else { //$NON-NLS-1$ //$NON-NLS-2$

			formatter.printHelp( "TSCmd", options ); //$NON-NLS-1$

			return;

		}

		if (cmd.hasOption("q")) { query = cmd.getOptionValue("q");} //$NON-NLS-1$ //$NON-NLS-2$

		if (cmd.hasOption("o")) { outdir = cmd.getOptionValue("o");	} //$NON-NLS-1$ //$NON-NLS-2$

		TSCorpusManager manager = new TSCorpusManager(registrydir, configdir);

		if (manager.isInitialized()) {

			TSCorpus corpus = manager.getCorpus(id);

			TSResult result = corpus.query(query);

			System.out.println(TXMCoreMessages.TSCmd_30+ query);

			System.out.println(String.valueOf(result.getNumberOfMatch())+ TXMCoreMessages.TSCmd_31);

			// write SVG of all matches

			for (int i = 0 ; i < result.getNumberOfMatch() ; i++) {

				File svgfile = new File(outdir, "result"+String.valueOf(i)+".svg"); //$NON-NLS-1$ //$NON-NLS-2$

				result.getMatch(i).toSVGFile(svgfile);

			}

		}

		return;

	}

}

// Copyright © 2010-2013 ENS de Lyon.

// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of

// Lyon 2, University of Franche-Comté, University of Nice

// Sophia Antipolis, University of Paris 3.

// 

// The TXM platform is free software: you can redistribute it

// and/or modify it under the terms of the GNU General Public

// License as published by the Free Software Foundation,

// either version 2 of the License, or (at your option) any

// later version.

// 

// The TXM platform is distributed in the hope that it will be

// useful, but WITHOUT ANY WARRANTY; without even the implied

// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

// PURPOSE. See the GNU General Public License for more

// details.

// 

// You should have received a copy of the GNU General

// Public License along with the TXM platform. If not, see

// http://www.gnu.org/licenses.

// 

// 

// 

// $LastChangedDate:$

// $LastChangedRevision:$

// $LastChangedBy:$ 

//

package org.txm.searchengine.ts;

import ims.tiger.gui.tigergraphviewer.TIGERGraphViewerConfiguration;

import java.io.File;

import java.util.HashMap;

import org.txm.core.messages.TXMCoreMessages;

// TODO: Auto-generated Javadoc

/**

 * The Class TSCorpusManager.

 */

public class TSCorpusManager {

	/** The corpora. */

	HashMap<String, TSCorpus> corpora = new HashMap<String, TSCorpus>();

	/** The registrydir. */

	private File registrydir;

	/** The configdir. */

	private File configdir;

	/** The initok. */

	private boolean initok = false;

	/**

	 * Instantiates a new tS corpus manager.

	 *

	 * @param registrydir the registrydir

	 * @param configdir the configdir

	 */

	public TSCorpusManager(File registrydir, File configdir)

	{

		this.registrydir = registrydir;

		this.configdir = configdir;

		initok = true;

		if (!(registrydir.exists() && registrydir.canRead())) {

			System.out.println(TXMCoreMessages.TSCorpusManager_0+registrydir);

			initok = false;

		}

		if (!(configdir.exists() && configdir.canRead())) {

			System.out.println(TXMCoreMessages.TSCorpusManager_1+configdir);

			initok = false;

		}

	}

	/**

	 * Gets the registry path.

	 *

	 * @return the registry path

	 */

	public String getRegistryPath() 

	{

		return registrydir.getAbsolutePath();

	}

	/**

	 * Gets the conf path.

	 *

	 * @return the conf path

	 */

	public String getconfPath() 

	{

		return configdir.getAbsolutePath();

	}

	/**

	 * Checks if is initialized.

	 *

	 * @return true, if is initialized

	 */

	public boolean isInitialized() {

		return initok;

	}

	/**

	 * Gets the corpus.

	 *

	 * @param id the id

	 * @return the corpus

	 */

	public TSCorpus getCorpus(String id)

	{

		if (!corpora.containsKey(id))

		{

			TSCorpus corpus = new TSCorpus(id, this);

			if (corpus.isOk())

				corpora.put(id, corpus);

		}

		return corpora.get(id);

	}

}

<html>

<body>

<p>Implementation of syntax querying using the TIGERSearch engine.

</body>

</html>

package org.txm.searchengine.ts;

import ims.tiger.index.writer.IndexBuilderErrorHandler;

import ims.tiger.index.writer.SimpleErrorHandler;

import ims.tiger.index.writer.XMLIndexing;

import java.io.File;

import java.io.IOException;

import org.apache.log4j.BasicConfigurator;

import org.txm.core.messages.TXMCoreMessages;

import org.xml.sax.SAXException;

public class TigerXmlIndexing{

	/* =================================================== */

	/* MAIN                                                */

	/* =================================================== */

	public static void main(String args[]) {

		BasicConfigurator.configure();

		String userdir = System.getProperty("user.home"); //$NON-NLS-1$

		File master = new File(userdir, "TXM/corpora/roland/tiger/master_pos.xml"); //$NON-NLS-1$

		if (!master.exists()) System.out.println(TXMCoreMessages.TigerXmlIndexing_2);

		if (!master.canRead()) System.out.println(TXMCoreMessages.TigerXmlIndexing_3);

		String uri = master.getAbsolutePath();

		File outdir = new File(userdir, "TXM/corpora/roland/tiger/data"); //$NON-NLS-1$

		outdir.delete();

		String dest = outdir.getAbsolutePath();

		//    String uri = "sources/tiger.xml";

		//    String dest = "/projekte/TIGER/java/testdir/work/TIGERCorpora/TIGER-250/";

		try {

			IndexBuilderErrorHandler handler = new SimpleErrorHandler(dest);

			XMLIndexing indexing = new XMLIndexing("TEST",uri, dest, handler,false); //$NON-NLS-1$

			indexing.startIndexing();

		}

		catch (IOException e) { System.out.println(TXMCoreMessages.TigerXmlIndexing_6+e.getMessage()); org.txm.utils.logger.Log.printStackTrace(e); }

		catch (SAXException e) { System.out.println(TXMCoreMessages.TigerXmlIndexing_7+e.getMessage()); org.txm.utils.logger.Log.printStackTrace(e);}

	}

}

// Copyright © 2010-2013 ENS de Lyon.

// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of

// Lyon 2, University of Franche-Comté, University of Nice

// Sophia Antipolis, University of Paris 3.

// 

// The TXM platform is free software: you can redistribute it

// and/or modify it under the terms of the GNU General Public

// License as published by the Free Software Foundation,

// either version 2 of the License, or (at your option) any

// later version.

// 

// The TXM platform is distributed in the hope that it will be

// useful, but WITHOUT ANY WARRANTY; without even the implied

// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

// PURPOSE. See the GNU General Public License for more

// details.

// 

// You should have received a copy of the GNU General

// Public License along with the TXM platform. If not, see

// http://www.gnu.org/licenses.

// 

// 

// 

// $LastChangedDate:$

// $LastChangedRevision:$

// $LastChangedBy:$ 

//

package org.txm.searchengine.ts;

import ims.tiger.corpus.Header;

import ims.tiger.export.ExportManager;

import ims.tiger.gui.tigergraphviewer.TIGERGraphViewerConfiguration;

import ims.tiger.query.internalapi.InternalCorpusQueryManager;

import ims.tiger.query.internalapi.InternalCorpusQueryManagerLocal;

import java.util.HashMap;

import java.util.List;

import org.txm.core.messages.TXMCoreMessages;

/**

 * The Class TSCorpus.

 */

public class TSCorpus {

	/** The id. */

	String id;

	/** The managers. */

	public TSCorpusManager tsmanager;

	InternalCorpusQueryManager manager = null;

	ExportManager exporter;