Laboratoire ICAR » Plateforme TXM

//  		  EntityCollection entities = null;

//           if(info != null) {

//           	entities = info.getOwner().getEntityCollection();

//           }

//

//           drawSecondaryPass(g2, plot, dataset, pass, series, item, domainAxis, dataArea, rangeAxis, crosshairState, entities);

		// Register the context menu

		TXMEditorPart.initContextMenu(this.viewer.getTable(), "IndexEditorContextMenu", this.getSite(), this.viewer); // $NON-NLS-1$

               <menuContribution

            locationURI="popup:IndexEditorContextMenu">

         <command

               commandId="org.txm.rcp.commands.link.ToConcordance"

               style="push">

         </command>

         <command

               commandId="org.txm.rcp.commands.link.IndexToCooccurrence"

               style="push">

         </command>

         <command

               commandId="org.txm.rcp.commands.link.ToProgression"

               style="push">

         </command>

      </menuContribution>

		if (getResult() instanceof Diagnostic)

			this.diag = (Diagnostic) getResult();

			CorpusManager.getCorpusManager().getCqiClient().dropSubCorpus(subcorpus.getQualifiedCqpId());

	public List<StructuralUnitProperty> getStructuralUnitProperties() throws CqiClientException {

	/** The structural unit. */

	 * 

	 * @param corpus

	 * @param s the String to 'deserialize'. Each property is separated with 1 tabulation. Then calls fromString on each token

	 * @return a list of StructuralUnitProperty if the s param is well formed

	 * @throws CqiClientException 

	 */

	public static List<StructuralUnitProperty> fromStringToList(Corpus corpus, String s) {

		ArrayList<StructuralUnitProperty> properties = new ArrayList<StructuralUnitProperty>();

		if (s == null) return properties;

		String[] split = s.split("\t");

		for (String s2 : split) {

			try {

				StructuralUnitProperty sup = fromString(corpus, s2);

				if (sup != null) {

					properties.add(sup);

				}

			} catch (Exception e) {

				e.printStackTrace();

			}

		}

		return properties;

	}

	/**

	public StructuralUnitProperty(StructuralUnit structuralUnit, String name, Corpus corpus) {

		return (this.getQualifiedName().compareTo((p).getQualifiedName()));

	private static final String BUNDLE_NAME = "org.txm.ca.rcp.messages.messages"; //$NON-NLS-1$

					getResult().setShowIndividuals(((ToolItem) e.getSource()).getSelection());

					getResult().setShowVariables(((ToolItem) e.getSource()).getSelection());

					getResult().setShowPointShapes(((ToolItem) e.getSource()).getSelection());

					getResult().setFirstDimension(dimension1);

					getResult().setSecondDimension(dimension2);

				getResult().setChartDirty();

				getResult().setNeedsToResetView(resetView);

				((CAEditor)getParentMultiPagesEditor()).setName(getResult().getName());

import org.txm.referencer.core.functions.Referencer;

		addField(new BooleanFieldEditor(RPreferences.SHOW_EVAL_LOGS, "Log the R eval command lines", getFieldEditorParent()));

            class="org.txm.referencer.core.preferences.ReferencerPreferences">

Export-Package: org.txm.referencer.core.functions,

 org.txm.referencer.core.preferences

package org.txm.referencer.core.preferences;

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

import org.osgi.framework.FrameworkUtil;

import org.osgi.service.prefs.Preferences;

import org.txm.core.preferences.TXMPreferences;

public class ReferencerPreferences extends TXMPreferences {

public static final String PREFERENCES_NODE = FrameworkUtil.getBundle(ReferencerPreferences.class).getSymbolicName();

	/** The Constant SORTBYFREQ. */

	//FIXME: to extract to referencer plug-in

	public static final String SORT_BY_FREQ = "sorttype"; //$NON-NLS-1$

	public static final String QUERY = "query"; //$NON-NLS-1$

	public static final String PROPERTY = "property"; //$NON-NLS-1$

	public static final String PATTERN = "pattern"; //$NON-NLS-1$

	@Override

	public void initializeDefaultPreferences() {

		Preferences preferences = DefaultScope.INSTANCE.getNode(PREFERENCES_NODE);

		preferences.putBoolean(SORT_BY_FREQ, false); //$NON-NLS-1$

		preferences.put(QUERY, ""); //$NON-NLS-1$

		preferences.put(PROPERTY, "word"); //$NON-NLS-1$

		preferences.put(PATTERN, "text_id"); //$NON-NLS-1$

	}

}

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

//

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

// 

// 

// 

// $LastChangedDate: 2016-11-29 16:47:07 +0100 (Tue, 29 Nov 2016) $

// $LastChangedRevision: 3349 $

// $LastChangedBy: mdecorde $ 

//

package org.txm.referencer.core.functions;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStreamWriter;

import java.io.Writer;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.txm.core.messages.TXMCoreMessages;

import org.txm.core.results.Parameter;

import org.txm.core.results.TXMParameters;

import org.txm.core.results.TXMResult;

import org.txm.referencer.core.preferences.ReferencerPreferences;

import org.txm.searchengine.cqp.AbstractCqiClient;

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

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

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

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.Query;

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

import org.txm.statsengine.r.core.RWorkspace;

import org.txm.statsengine.r.core.exceptions.RWorkspaceException;

import org.txm.utils.logger.Log;

/**

 * The Class Referencer computes the references of a query

 */

public class Referencer extends TXMResult  {

	/** The noref. */

	protected static int noref = 1;

	/** The prefix r. */

	protected static String prefixR = "Referencer"; //$NON-NLS-1$

	/** The indexes. */

	int[] indexes;

	/** The lines. */

	List<Line> lines;

	/** The cache. */

	//private Map<Property, CqpDataProxy> cache;

	/** The matches. */

	List<Match> matches;

	/** The positions. */

	int[] positions;

	/** The nlines. */

	int nlines;

	/** The processed idx. */

	HashMap<Integer, Line> processedIdx;

	/** The result. */

	QueryResult result;

	/** The symbol. */

	private String symbol;

	/** The writer. */

	private BufferedWriter writer;

	/** The hierarchic sort. */

	@Parameter(key=ReferencerPreferences.SORT_BY_FREQ)

	private boolean pHierarchicSort;

	@Parameter

	List<StructuralUnitProperty> pPattern;

	/** The prop. */

	@Parameter

	Property pProperty;

	/** The query. */

	@Parameter

	Query pQuery;

	/**

	 * Instantiates a new referencer.

	 *

	 * @param corpus the corpus

	 * @param pQuery the query

	 * @param pProperty the prop

	 * @param pPattern the pattern

	 * @param pHierarchicSort the hierarchic sort

	 */

	public Referencer(Corpus corpus) {

		super(corpus);

	}

	/**

	 * As r matrix.

	 *

	 * @return the string

	 * @throws RWorkspaceException the r workspace exception

	 */

	public String asRMatrix() throws RWorkspaceException {

		String keywords[] = new String[lines.size()];

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

			keywords[i] = lines.get(i).getPropValue();

		//System.out.println(Arrays.toString(keywords));

		String symbol = prefixR+noref;

		RWorkspace rw = RWorkspace.getRWorkspaceInstance();

		rw.eval(symbol+" <- list()"); //$NON-NLS-1$

		rw.addVectorToWorkspace("refkeywords", keywords); //$NON-NLS-1$

		rw.eval(symbol+"$keywords <- refkeywords"); //$NON-NLS-1$

		//rw.eval(symbol+"$query <- \""+this.query.getQueryString()+"\")");

		rw.eval(symbol+"$refs <- list()"); //$NON-NLS-1$

		int i = 1;

		for (Line line : this.lines) {

			String refs[] = line.getReferences().toArray(new String[line.getReferences().size()]);

			//System.out.println(line.getPropValue()+": "+Arrays.toString(refs));

			rw.addVectorToWorkspace("reflinerefs", refs); //$NON-NLS-1$

			rw.eval(symbol+"$refs[["+i+"]] <- reflinerefs"); //$NON-NLS-1$ //$NON-NLS-2$

			i++;

		}

		noref++;

		this.symbol = symbol;

		return symbol;

	}

	@Override

	public void clean() {

		try {

			if (this.writer != null) {

				this.writer.flush();

				this.writer.close();	

			}

		} catch (IOException e) {

			// TODO Auto-generated catch block

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

		}

	}

	/**

	 * Clear all lines.

	 */

	public void clearAllLines()

	{

		for(Line line : lines) { // we need to recompute lines' references

			line.clear();

		}

	}

	/**

	 * Call in order all stages to compute the referencer.

	 *

	 * @return true, if successful

	 */

	protected boolean _compute() {

		try {

			if (!getQueryMatches())

				return false;

			if (!getQueryindexes())

				return false;

			if (!groupPositionsbyId())

				return false;

		}

		catch(CqiClientException e) {

			e.printStackTrace();

			return false;

		}

		return true;

	}

	/**

	 * Gets the parent corpus.

	 *

	 * @return the corpus

	 */

	public Corpus getCorpus() {

		return (Corpus) this.parent;

	}

	@Override

	public String getDetails() {

		return getCorpus().getName();

	}

	/**

	 * Gets the lines.

	 *

	 * @return the lines

	 * @throws CqiClientException the cqi client exception

	 * @throws IOException Signals that an I/O exception has occurred.

	 * @throws CqiServerError the cqi server error

	 */

	public List<Line> getLines() throws CqiClientException, IOException, CqiServerError

	{

		return getLines(0,lines.size());

	}

	/**

	 * Gets the lines.

	 *

	 * @param from the from

	 * @param to the to

	 * @return the lines

	 * @throws CqiClientException the cqi client exception

	 * @throws IOException Signals that an I/O exception has occurred.

	 * @throws CqiServerError the cqi server error

	 */

	public List<Line> getLines(int from, int to) throws CqiClientException, IOException, CqiServerError

	{

		if (from < 0)

			from = 0;

		if (to > lines.size())

			to = lines.size();

		HashMap<Integer, Line> lineswithoutpropvalue = new HashMap<Integer, Line>();

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

		//build Missing lines

		for(int i = from ; i < to ; i++)// for each position group

		{

			Line l = lines.get(i);

			if (l.notcomputed) {

				lineswithoutpropvalue.put(l.id, l);

				// get all reference values of all position of the line

				Map<Property, List<List<String>>> refValues = new HashMap<Property, List<List<String>>>();

				for (Property property : pPattern) {

					refValues.put(property, cqiClient.getData(property,

							l.positions, Collections.nCopies(l.positions.size(), 1)));

				}

				for (int j = 0 ; j < l.positions.size() ; j++)// build the Reference object

				{

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

					for (Property property : pPattern) {

						propvalue += refValues.get(property).get(j).get(0)+", "; //$NON-NLS-1$

					}

					l.addReference(propvalue.substring(0, propvalue.length()-2));

				}

				if (pHierarchicSort)

					l.sortRef(true);

				else

					l.sortAlpha();

				l.notcomputed = false;

			}

		}

		// get idx String value

		int[] idxwithoutvalues = new int[lineswithoutpropvalue.keySet().size()];

		int count = 0;

		for(int i : lineswithoutpropvalue.keySet()) {

			idxwithoutvalues[count++] = i;

		}

		String[] values = CorpusManager.getCorpusManager().getCqiClient().id2Str(pProperty.getQualifiedName(), idxwithoutvalues);

		for(int i = 0 ; i < values.length ; i++) {

			int id = idxwithoutvalues[i];

			lineswithoutpropvalue.get(id).linepropvalue = values[i];

		}

		return lines.subList(from, to);

	}

	/**

	 * Gets the name.

	 *

	 * @return the name

	 */

	public String getName() {

		return getCorpus().getName() + ": " + pQuery; //$NON-NLS-1$

	}

	/**

	 * Gets the n lines.

	 *

	 * @return the n lines

	 */

	public int getNLines() {

		return nlines;

	}

	/**

	 * Gets the pattern.

	 *

	 * @return the pattern

	 */

	public List<StructuralUnitProperty> getPattern() {

		return pPattern;

	}

	/**

	 * Gets the property.

	 *

	 * @return the property

	 */

	public Property getProperty() {

		return pProperty;

	}

	/**

	 * Gets the query.

	 *

	 * @return the query

	 */

	public Query getQuery() {

		return pQuery;

	}

	/**

	 * 2nd step.

	 *

	 * @return the queryindexes

	 */

	public boolean getQueryindexes(){

		try {

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

			int i = 0;

			for (Match m : matches) {

				positions[i++] = m.getStart();

			}

			indexes = CorpusManager.getCorpusManager().getCqiClient().cpos2Id(pProperty.getQualifiedName(),positions);

		} catch (Exception e) {

			// TODO Auto-generated catch block

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

			return false;

		}

		return true;

	}

	/**

	 * 1st step.

	 *

	 * @return the query matches

	 * @throws CqiClientException 

	 */

	public boolean getQueryMatches() throws CqiClientException{

		result = this.getCorpus().query(pQuery, TXMCoreMessages.Referencer_1, false);

		if (result.getNMatch() == 0)

			return false;

		matches = result.getMatches();

		result.drop();

		return true;

	}

	@Override

	public String getSimpleName() {

		if (pQuery != null) {

			return pQuery.toString();

		}

		else {

			return getName();

		}

	}

	/**

	 * Gets the symbol.

	 *

	 * @return the symbol

	 */

	public String getSymbol() {

		return symbol;

	}

	public int getV() {

		if (matches == null) {

			return 0;

		}

		return matches.size();

	}

	/**

	 * 3rd stage.

	 *

	 * @return true, if successful

	 */

	public boolean groupPositionsbyId() {

		processedIdx = new HashMap<Integer, Line>();

		lines = new ArrayList<Line>();

		//System.out.println("indexes ");

		for (int i = 0 ; i < indexes.length ; i++) {

			int id = indexes[i];

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

			if (!processedIdx.containsKey(id)) {	

				//System.out.println("add idx "+id);

				Line l = new Line(id);

				processedIdx.put(id, l);

				lines.add(l);

			}

			processedIdx.get(id).addPosition(positions[i]);

		}

		nlines = processedIdx.keySet().size();

		return true;

	}

	public void setParameters(Query query, Property prop, List<StructuralUnitProperty> pattern, Boolean hierarchicSort) {

		if (query != null) this.pQuery = query;

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

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

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

		dirty = true;

	}

	@Override

	public boolean setParameters(TXMParameters parameters) {

		return false;

	}

	/**

	 * Write all the lines in a file.

	 *

	 * @param outfile the outfile

	 * @param encoding the encoding

	 * @return true, if successful

	 */

	public boolean toTxt(File outfile, String encoding) {

		return toTxt(outfile, encoding, "\t", ""); //$NON-NLS-1$ //$NON-NLS-2$

	}

	/**

	 * Write all the lines in a file.

	 *

	 * @param outfile the outfile

	 * @param encoding the encoding

	 * @param colseparator the colseparator

	 * @param txtseparator the txtseparator

	 * @return true, if successful

	 */

	public boolean toTxt(File outfile, String encoding, String colseparator, String txtseparator) {

		try {

			// NK: writer declared as class attribute to perform a clean if the operation is interrupted

			this.writer = new BufferedWriter(new OutputStreamWriter(

					new FileOutputStream(outfile), encoding)); 

			// if ("UTF-8".equals(encoding)) writer.write('\ufeff'); // UTF-8 BOM

			toTxt(writer, 0, lines.size() - 1, colseparator, txtseparator);

		} catch (Exception e) {

			System.err.println(TXMCoreMessages.Referencer_2 + Log.toString(e));

			return false;

		}

		return true;

	}

	/**

	 * Write the lines between from and to in a writer.

	 *

	 * @param writer Where to write the lines

	 * @param from The first line to be written

	 * @param to The last line to be writen

	 * @param colseparator the colseparator

	 * @param txtseparator the txtseparator

	 * @throws CqiClientException the cqi client exception

	 * @throws IOException Signals that an I/O exception has occurred.

	 */

	public void toTxt(Writer writer, int from, int to, String colseparator, String txtseparator)

			throws CqiClientException, IOException {

		try {

			getLines(0, 9999999);

			writer.write(pProperty.getName()+colseparator+this.pPattern+"\n"); //$NON-NLS-1$

			for (Line line : lines) {

				writer.write(txtseparator+line.getPropValue().replace(txtseparator, txtseparator+txtseparator)+txtseparator+ colseparator + txtseparator+ line.getReferences().toString().replace(txtseparator, txtseparator+txtseparator)+txtseparator+"\n"); //$NON-NLS-1$

				writer.flush();

			}

			writer.close();

		} catch (CqiServerError e) {

			// TODO Auto-generated catch block

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

		}

	}

	@Override

	public boolean canCompute() {

		if (pQuery == null 

				|| pQuery.isEmpty()) {

			System.out.println("Empty query");

			return false;

		}

		if (pPattern == null 

				|| pPattern.size() == 0) {

			System.out.println("No reference pattern");

			return false;

		}

		if (pProperty == null) {

			System.out.println("No property");

			return false;

		}

		return true;

	}

	@Override

	public boolean loadParameters() throws CqiClientException {

		this.pQuery = new Query(this.getStringParameterValue(ReferencerPreferences.QUERY));

		String s = this.getStringParameterValue(ReferencerPreferences.PATTERN);

		this.pPattern = StructuralUnitProperty.fromStringToList(getCorpus(), s);

		s = this.getStringParameterValue(ReferencerPreferences.PROPERTY);

		this.pProperty = getCorpus().getProperty(s);

		return true;

	}

	@Override

	public boolean saveParameters() {

		// TODO Auto-generated method stub

		System.err.println("Referencer.saveParameters(): not yet implemented.");

		return true;

	}

	/**

	 * The Class Line.

	 */

	public class Line {

		/** The id. */

		int id;

		/** The propvalue. */

		String linepropvalue;

		/** The notcomputed. */

		boolean notcomputed=true;

		/** The positions. */

		ArrayList<Integer> positions;

		/** The references. */

		ArrayList<String> references;

		/** The references counts. */

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

		/**

		 * Instantiates a new line.

		 *

		 * @param i the i

		 */

		public Line(int i) {

			id = i;

			positions = new ArrayList<Integer>();

			references = new ArrayList<String>();

		}

		/**

		 * Adds the position.

		 *

		 * @param i the i

		 */

		public void addPosition(int i) {

			positions.add(i);

		}

		/**

		 * Adds the reference.

		 *

		 * @param string the string

		 */

		public void addReference(String string) {

			if (!referencesCounts.containsKey(string)) {

				references.add(string);

				referencesCounts.put(string, 1);

			} else {

				referencesCounts.put(string, referencesCounts.get(string)+1);

			}

		}

		/**

		 * Clear.

		 */

		public void clear() {

			notcomputed = false;

			references = new ArrayList<String>();

		}

		/**

		 * Gets the count.

		 *

		 * @param ref the ref

		 * @return the count

		 */

		public int getCount(String ref) {

			return referencesCounts.get(ref);

		}

		public HashMap<String, Integer> getCounts() {

			return referencesCounts;

		}

		/**

		 * Gets the prop value.

		 *

		 * @return the prop value

		 */

		public String getPropValue() {

			return linepropvalue;

		}

		/**

		 * Gets the references.

		 *

		 * @return the references

		 */

		public List<String> getReferences() {

			return references;

		}

		/**

		 * Sort alpha.

		 */

		public void sortAlpha() {

			Collections.sort(references);

		}

		/**

		 * Sort ref.

		 *

		 * @param reverse the reverse

		 */

		public void sortRef(final boolean reverse) {

			Collections.sort(references, new Comparator<String>() {

				@Override

				public int compare(String arg0, String arg1) {

					if (reverse)

						return getCount(arg1) - getCount(arg0);

					else

						return getCount(arg0) - getCount(arg1);

				}

			});

		}

		/* (non-Javadoc)

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

		 */

		@Override

		public String toString() {

			return linepropvalue+" : <"+id+","+pProperty+"> : "+references.toString(); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

		}

	}

	public void setQuery(Query query) {

		this.pQuery = query;

	}

	public void setProperty(Property property) {

		this.pProperty = property;

	}

	public void setPattern(List<StructuralUnitProperty> properties) {

		this.pPattern = properties;

	}

}

<html>

<body>

<p>Compute an index such as those in books</p>

</body>

</html>

import org.txm.referencer.core.functions.Referencer;

import org.txm.referencer.core.functions.Referencer;

		lexicalTable = (LexicalTable) this.getResult();

		// Register the context menu

		TXMEditorPart.initContextMenu(this.viewer.getTable(), "LexicalTableEditorContextMenu", this.getSite(), this.viewer); // $NON-NLS-1$

            locationURI="popup:LexicalTableEditorContextMenu">

encoding//src/org/txm/internalview/rcp/messages/messages.properties=UTF-8

encoding//src/org/txm/internalview/rcp/messages/messages_fr.properties=UTF-8

encoding//src/org/txm/internalview/rcp/messages/messages_ru.properties=UTF-8

Export-Package: org.txm.internalview.rcp.adapters,

 org.txm.internalview.rcp.editors,

 org.txm.internalview.rcp.handlers,

 org.txm.internalview.rcp.messages