Laboratoire ICAR » Plateforme TXM

eclipse.preferences.version=1

org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled

org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6

org.eclipse.jdt.core.compiler.compliance=1.6

org.eclipse.jdt.core.compiler.problem.assertIdentifier=error

org.eclipse.jdt.core.compiler.problem.enumIdentifier=error

org.eclipse.jdt.core.compiler.source=1.6

<?xml version="1.0" encoding="UTF-8"?>

<classpath>

	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>

	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>

	<classpathentry kind="src" path="src"/>

	<classpathentry kind="output" path="bin"/>

</classpath>

Manifest-Version: 1.0

Bundle-ManifestVersion: 2

Bundle-Name: Core

Bundle-SymbolicName: org.txm.concordance.core

Bundle-Version: 1.0.0.qualifier

Bundle-RequiredExecutionEnvironment: JavaSE-1.6

Require-Bundle: org.txm.core

<?xml version="1.0" encoding="UTF-8"?>

<projectDescription>

	<name>org.txm.concordance.core</name>

	<comment></comment>

	<projects>

	</projects>

	<buildSpec>

		<buildCommand>

			<name>org.eclipse.jdt.core.javabuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

		<buildCommand>

			<name>org.eclipse.pde.ManifestBuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

		<buildCommand>

			<name>org.eclipse.pde.SchemaBuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

	</buildSpec>

	<natures>

		<nature>org.eclipse.pde.PluginNature</nature>

		<nature>org.eclipse.jdt.core.javanature</nature>

	</natures>

</projectDescription>

// 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: 2016-02-01 09:53:38 +0100 (Mon, 01 Feb 2016) $

// $LastChangedRevision: 3101 $

// $LastChangedBy: mdecorde $ 

//

package org.txm.functions.concordances;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import org.apache.commons.lang.StringUtils;

import org.txm.annotation.Annotation;

import org.txm.annotation.repository.TypedValue;

import org.txm.functions.Reference;

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

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

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

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

import org.txm.utils.i18n.LangFormater;

// TODO: Auto-generated Javadoc

/**

 * The Class Line represents concordance line.

 *

 * @author jmague

 */

public class Line {

	/** The concordance. */

	private Concordance concordance;

	/** The left ctx view properties. */

	private Map<Property, List<String>> leftCtxViewProperties;

	/** The keywords view properties. */

	private Map<Property, List<String>> keywordsViewProperties;

	/** The right ctx view properties. */

	private Map<Property, List<String>> rightCtxViewProperties;

	/** The left ctx analysis property. */

	private HashMap<Property, List<String>> leftCtxAnalysisProperty;

	/** The keywords analysis property. */

	private HashMap<Property, List<String>> keywordsAnalysisProperty;

	/** The right ctx analysis property. */

	private HashMap<Property, List<String>> rightCtxAnalysisProperty;

	/** The PRO p_ separtor. */

	public static String PROP_SEPARTOR ="_"; //$NON-NLS-1$

	/** The references : view and sort */

	private Reference refView;

	private Reference refAna;

	/** The match. */

	private Match match;

	/** the line's text. */

	private String textId;

	/** the ids of the keywords. */

	private List<String> keywordsIdValues;

	/** The keywordpos. */

	private int keywordpos;

	/**

	 * the @target corpus position of the query

	 */

	private int targetpos;

	private TypedValue annotationValue;

	private Annotation annotation;

	/**

	 * Instantiates a new line.

	 *

	 * @param concordance the concordance

	 * @param keywordsIdValues the keywords id values

	 * @param textId the text id

	 * @param leftCtxViewProperty the left context view property values

	 * @param keywordsViewProperty the keywords view property values

	 * @param rightCtxViewProperty the right context view property values

	 * @param lineLeftCtxAnaPropValue the left context analysis property values

	 * @param lineKeywordsAnaPropValue the keywords analysis property values

	 * @param lineRightCtxAnaPropValue the right context analysis property values

	 * @param refView the view references

	 * @param reference2 the sort references

	 * @param matchs the matchs

	 * @param annotation 

	 * @param annotationValue 

	 */

	public Line(Concordance concordance, List<String> keywordsIdValues,

			String textId, Map<Property, List<String>> leftCtxViewProperty,

			Map<Property, List<String>> keywordsViewProperty,

			Map<Property, List<String>> rightCtxViewProperty,

			HashMap<Property, List<String>> lineLeftCtxAnaPropValue,

			HashMap<Property, List<String>> lineKeywordsAnaPropValue,

			HashMap<Property, List<String>> lineRightCtxAnaPropValue, Reference refView,

			Reference refAna, Match matchs, Annotation annotation, TypedValue annotationValue, int targetpos) {

		this.textId = textId;

		this.targetpos = targetpos;

		this.keywordsIdValues = keywordsIdValues;

		this.concordance = concordance;

		this.leftCtxViewProperties = leftCtxViewProperty;

		this.keywordsViewProperties = keywordsViewProperty;

		this.rightCtxViewProperties = rightCtxViewProperty;

		this.leftCtxAnalysisProperty = lineLeftCtxAnaPropValue;

		this.keywordsAnalysisProperty = lineKeywordsAnaPropValue;

		this.rightCtxAnalysisProperty = lineRightCtxAnaPropValue;

		this.refView = refView;

		this.refAna = refAna;

		this.match = matchs;

		this.keywordpos = matchs.getStart();

		this.annotationValue = annotationValue;

		this.annotation = annotation;

	}

	/**

	 * Gets the keywords analysis property.

	 * 

	 * @return the keywords analysis property

	 */

	public HashMap<Property, List<String>> getKeywordsAnalysisProperty() {

		return keywordsAnalysisProperty;

	}

	public TypedValue getAnnotationValue() {

		return annotationValue;

	}

	/**

	 * Gets the left context analysis property.

	 * 

	 * @return the left context analysis property

	 */

	public HashMap<Property, List<String>> getLeftAnalysisProperty() {

		return leftCtxAnalysisProperty;

	}

	/**

	 * Gets the right ctx analysis property.

	 * 

	 * @return the right ctx analysis property

	 */

	public HashMap<Property, List<String>> getRightAnalysisProperty() {

		return rightCtxAnalysisProperty;

	}

	/**

	 * Gets the keywords view properties.

	 * 

	 * @return the keywords view properties

	 */

	public Map<Property, List<String>> getKeywordsViewProperties() {

		return keywordsViewProperties;

	}

	/**

	 * Gets the left context view properties.

	 * 

	 * @return the left context view properties

	 */

	public Map<Property, List<String>> getLeftCtxViewProperties() {

		return leftCtxViewProperties;

	}

	/**

	 * Gets the right context view properties.

	 * 

	 * @return the right context view properties

	 */

	public Map<Property, List<String>> getRightCtxViewProperties() {

		return rightCtxViewProperties;

	}

	/**

	 * Gets the reference.

	 * 

	 * @return the reference

	 */

	public Reference getViewRef() {

		return refView;

	}

	/**

	 * Gets the reference.

	 * 

	 * @return the reference

	 */

	public Reference getAnaRef() {

		return refAna;

	}

	/**

	 * Gets the left context size.

	 * 

	 * @return the left context size

	 */

	public int getLeftContextSize() {

		return leftCtxViewProperties.values().iterator().next().size();

	}

	/**

	 * Gets the keywords size.

	 * 

	 * @return the keywords size

	 */

	public int getKeywordsSize() {

		return keywordsViewProperties.values().iterator().next().size();

	}

	/**

	 * Gets the right context size.

	 * 

	 * @return the right context size

	 */

	public int getRightContextSize() {

		return rightCtxViewProperties.values().iterator().next().size();

	}

	/**

	 * Gets the match.

	 * 

	 * @return the match

	 */

	public Match getMatch() {

		return match;

	}

	/**

	 * Used by leftContextToString, keywordsToString and rightContextToString to

	 * build te string they return.

	 *

	 * @param values A map returned by getLeftCtxViewProperties,

	 * getKeywordsViewProperties or getRightCtxViewProperties

	 * @param propertySeparator The string used to separate the dif ferent view properties for

	 * each word

	 * @param wordSeparator The string used to separate the dif ferent words

	 * @return The string representation

	 */

	private String fieldToString(Map<Property, List<String>> values,

			String propertySeparator, String wordSeparator) {

		List<String> words = new ArrayList<String>();

		for (int i = 0; i < values.get(concordance.getViewProperties().get(0))

				.size(); i++) {

			List<String> word = new ArrayList<String>();

			for (Property property : concordance.getViewProperties())

				word.add(values.get(property).get(i));

			words.add(StringUtils.join(word, propertySeparator));

		}

		return LangFormater.format(StringUtils.join(words, wordSeparator),

				concordance.getCorpus().getAttribute("lang")); //$NON-NLS-1$

	}

	/**

	 * Fix spaces.

	 *

	 * @param str the str

	 * @return the string

	 */

	private String fixSpaces(String str) {

		str = str.replace(" ' ", " '"); //$NON-NLS-1$ //$NON-NLS-2$

		str = str.replace("' ", "'"); //$NON-NLS-1$ //$NON-NLS-2$

		str = str.replace(" , ", ", "); //$NON-NLS-1$ //$NON-NLS-2$

		str = str.replace(" \" ", " \""); //$NON-NLS-1$ //$NON-NLS-2$

		str = str.replace(" . ", ". "); //$NON-NLS-1$ //$NON-NLS-2$

		str = str.replace("( ", "("); //$NON-NLS-1$ //$NON-NLS-2$

		str = str.replace(" )", ")"); //$NON-NLS-1$ //$NON-NLS-2$

		str = str.replace("[ ", "["); //$NON-NLS-1$ //$NON-NLS-2$

		str = str.replace(" ]", "]"); //$NON-NLS-1$ //$NON-NLS-2$

		str = str.replace("{ ", "{"); //$NON-NLS-1$ //$NON-NLS-2$

		str = str.replace(" }", "}"); //$NON-NLS-1$ //$NON-NLS-2$

		return str;

	}

	/**

	 * Returns a string representing the left context.

	 *

	 * @param propertySeparator The string used to separate the dif ferent view properties for

	 * each word

	 * @param wordSeparator The string used to separate the dif ferent words

	 * @param limit the limit

	 * @return The string representation

	 */

	public String leftContextToString(String propertySeparator,

			String wordSeparator, int limit) {

		int currentPos = keywordpos - getLeftContextSize();

		List<String> words = new ArrayList<String>();

		Map<Property, List<String>> values = getLeftCtxViewProperties();

		int max = (limit == -1) ? (values.get(concordance

				.getLeftViewProperties().get(0)).size()) : (limit);

		int start = this.getLeftContextSize() - max;

		for (int i = start; i < this.getLeftContextSize(); i++) {

			List<String> word = new ArrayList<String>();

			for (Property property : concordance.getLeftViewProperties())

				word.add(values.get(property).get(i));

			words.add(StringUtils.join(word, propertySeparator));

			if (annotation != null) {

				if (currentPos == annotation.getStart()) {

					words.set(i, "< "+words.get(i));

				} else if (currentPos == annotation.getEnd()) {

					words.set(i, words.get(i)+" >");

				}

			}

			currentPos++; // next position

		}

		return LangFormater.format(StringUtils.join(words, wordSeparator),

				concordance.getCorpus().getAttribute("lang")); //$NON-NLS-1$

		// return fieldToString(getLeftCtxViewProperties(), propertySeparator,

		// wordSeparator);

	}

	/**

	 * Returns a string representing the keywords.

	 *

	 * @param propertySeparator The string used to separate the dif ferent view properties for

	 * each word

	 * @param wordSeparator The string used to separate the dif ferent words

	 * @return The string representation

	 */

	public String keywordToString(String propertySeparator, String wordSeparator) {

		int currentPos = keywordpos;

		List<String> words = new ArrayList<String>();

		Map<Property, List<String>> values = getKeywordsViewProperties();

		int s = values.get(concordance.getKeywordViewProperties().get(0)).size();

		int keywordEndPos = keywordpos + s - 1;

		//System.out.println("Build STR of currentpos="+currentPos+" length="+s);

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

			List<String> word = new ArrayList<String>();

			for (Property property : concordance.getKeywordViewProperties())

				word.add(values.get(property).get(i));

			if (currentPos == targetpos) { // highlight the @ target 

				words.add("["+StringUtils.join(word, propertySeparator)+"]");

			} else {

				words.add(StringUtils.join(word, propertySeparator));

			}

			if (annotation != null && (annotation.getStart() != keywordpos || annotation.getEnd() != keywordEndPos)) {

				if (currentPos == annotation.getStart()) {

					words.set(i, "< "+words.get(i));

				}

				if (currentPos == annotation.getEnd()) {

					words.set(i, words.get(i)+" >");

				}

			}

			currentPos++; // next position

		}

		return LangFormater.format(StringUtils.join(words, wordSeparator),

				concordance.getCorpus().getAttribute("lang")); //$NON-NLS-1$

		// return fieldToString(getKeywordsViewProperties(), propertySeparator,

		// wordSeparator);

	}

	/**

	 * Returns a string representing the right context.

	 *

	 * @param propertySeparator The string used to separate the dif ferent view properties for

	 * each word

	 * @param wordSeparator The string used to separate the dif ferent words

	 * @param limit the limit

	 * @return The string representation

	 */

	public String rightContextToString(String propertySeparator,

			String wordSeparator, int limit) {

		List<String> words = new ArrayList<String>();

		Map<Property, List<String>> values = getRightCtxViewProperties();

		int max = (limit == -1) ? (values.get(concordance.getRightViewProperties().get(0)).size()) : (limit);

		int s = getKeywordsSize();

		int currentPos = keywordpos + s;

		//System.out.println("Line "+keywordToString()+" right context, currentpos="+currentPos+" keywordpos="+keywordpos+" keywordlength="+s);

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

			List<String> word = new ArrayList<String>();

			for (Property property : concordance.getRightViewProperties())

				word.add(values.get(property).get(i));

			words.add(StringUtils.join(word, propertySeparator));

			if (annotation != null) {

				if (currentPos == annotation.getStart()) {

					words.set(i, "< "+words.get(i));

				} else if (currentPos == annotation.getEnd()) {

					words.set(i, words.get(i)+" >");

				}

			}

			currentPos++;

		}

		return LangFormater.format(StringUtils.join(words, wordSeparator),

				concordance.getCorpus().getLang()); 

		// return fieldToString(getRightCtxViewProperties(), propertySeparator,

		// wordSeparator);

	}

	/** The properties to process. */

	protected static HashSet<String> propertiesToProcess;

	/**

	 * Right context render.

	 *

	 * @param limit the limit

	 * @return the string

	 */

	public String rightContextRender(int limit)

	{

//		if(propertiesToProcess == null)

//			propertiesToProcess = TxmRenderer.getPropertyToRender(concordance, "jsesh"); //$NON-NLS-1$

		List<String> words = new ArrayList<String>();

		Map<Property, List<String>> values = getRightCtxViewProperties();

		int max = (limit == -1) ? (values.get(concordance.getRightViewProperties().get(0)).size()) : (limit);

		for (int i = 0; i < max; i++) 

		{

			List<String> word = new ArrayList<String>();

			for (Property property : concordance.getRightViewProperties())

			{

//				if(propertiesToProcess.contains(property.getName()))

//					word.add(TxmRenderer.jseshrenderer.render(values.get(property).get(i)));

//				else

					word.add(values.get(property).get(i));

			}

			words.add(StringUtils.join(word, "_")); //$NON-NLS-1$

		}

		return LangFormater.format(StringUtils.join(words, " "), //$NON-NLS-1$

				concordance.getCorpus().getAttribute("lang")); //$NON-NLS-1$

	}

	/**

	 * Keyword render.

	 *

	 * @param wordSeparator the word separator

	 * @return the string

	 */

	public String keywordRender(String wordSeparator) {

//		if(propertiesToProcess == null)

//			propertiesToProcess = TxmRenderer.getPropertyToRender(concordance, "jsesh"); //$NON-NLS-1$

		List<String> words = new ArrayList<String>();

		Map<Property, List<String>> values = getKeywordsViewProperties();

		for (int i = 0; i < values.get(

				concordance.getKeywordViewProperties().get(0)).size(); i++) {

			List<String> word = new ArrayList<String>();

			for (Property property : concordance.getKeywordViewProperties())

			{

//				if(propertiesToProcess.contains(property.getName()))

//					word.add(TxmRenderer.jseshrenderer.render(values.get(property).get(i)));

//				else

					word.add(values.get(property).get(i));

			}

			words.add(StringUtils.join(word, wordSeparator));

		}

		return LangFormater.format(StringUtils.join(words, wordSeparator),

				concordance.getCorpus().getAttribute("lang")); //$NON-NLS-1$

	}

	/**

	 * Left context render.

	 *

	 * @param limit the limit

	 * @return the string

	 */

	public String leftContextRender(int limit) {

		List<String> words = new ArrayList<String>();

		Map<Property, List<String>> values = getLeftCtxViewProperties();

		int max = (limit == -1) ? (values.get(concordance

				.getLeftViewProperties().get(0)).size()) : (limit);

		int start = this.getLeftContextSize() - max;

		for (int i = start; i < this.getLeftContextSize(); i++) {

			List<String> word = new ArrayList<String>();

			for (Property property : concordance.getLeftViewProperties())

			{

//				if(propertiesToProcess.contains(property.getName()))

//					word.add(TxmRenderer.jseshrenderer.render(values.get(property).get(i)));

//				else

					word.add(values.get(property).get(i));

			}

			words.add(StringUtils.join(word, "_")); //$NON-NLS-1$

		}

		return LangFormater.format(StringUtils.join(words, " "), //$NON-NLS-1$

				concordance.getCorpus().getAttribute("lang")); //$NON-NLS-1$

		// return fieldToString(getLeftCtxViewProperties(), propertySeparator,

		// wordSeparator);

	}

	/**

	 * Returns a string representing the left context. Equivalent to

	 * leftContextToString("/"," ")

	 * 

	 * @return The string representation

	 */

	public String leftContextToString() {

		return leftContextToString(PROP_SEPARTOR, " ", -1); //$NON-NLS-1$ 

	}

	/**

	 * Left context to string.

	 *

	 * @param limit the limit

	 * @return the string

	 */

	public String leftContextToString(int limit) {

		return leftContextToString(PROP_SEPARTOR, " ", limit); //$NON-NLS-1$ 

	}

	/**

	 * Returns a string representing the keywords. Equivalent to

	 * keywordToString("/"," ")

	 * 

	 * @return The string representation

	 */

	public String keywordToString() {

		return keywordToString(PROP_SEPARTOR, " "); //$NON-NLS-1$ 

	}

	/**

	 * Returns a string representing the right context. Equivalent to

	 * rightContextToString("/"," ")

	 * 

	 * @return The string representation

	 */

	public String rightContextToString() {

		return rightContextToString(PROP_SEPARTOR, " ", -1); //$NON-NLS-1$ 

	}

	/**

	 * Right context to string.

	 *

	 * @param limit the limit

	 * @return the string

	 */

	public String rightContextToString(int limit) {

		return rightContextToString(PROP_SEPARTOR, " ", limit); //$NON-NLS-1$ 

	}

	/**

	 * Match get start.

	 *

	 * @return the integer

	 */

	public Integer matchGetStart() {

		return match.getStart();

	}

	/**

	 * Match get end.

	 *

	 * @return the integer

	 */

	public Integer matchGetEnd() {

		return match.getEnd();

	}

	/**

	 * Match get col.

	 *

	 * @param corpus the corpus

	 * @return the string

	 * @throws CqiClientException the cqi client exception

	 */

	public String matchGetCol(Corpus corpus) throws CqiClientException {

		return match.getValueForProperty(corpus.getProperty("col")); //$NON-NLS-1$

	}

	/**

	 * Match get id.

	 *

	 * @param corpus the corpus

	 * @return the list

	 * @throws CqiClientException the cqi client exception

	 */

	public List<String> matchGetId(Corpus corpus) throws CqiClientException {

		return match.getValuesForProperty(corpus.getProperty("id")); //$NON-NLS-1$

	}

	/**

	 * Match get id.

	 *

	 * @param corpus the corpus

	 * @param positions the positions

	 * @return the list

	 * @throws CqiClientException the cqi client exception

	 */

	@SuppressWarnings("static-access") //$NON-NLS-1$

	public List<String> matchGetId(Corpus corpus, int[] positions)

			throws CqiClientException {

		return match.getValuesForProperty(corpus.getProperty("id"), positions); //$NON-NLS-1$

	}

	/**

	 * Match get propertie.

	 *

	 * @param corpus the corpus

	 * @param propertie the propertie

	 * @param positions the positions

	 * @return the list

	 * @throws CqiClientException the cqi client exception

	 */

	@SuppressWarnings("static-access") //$NON-NLS-1$

	public List<String> matchGetPropertie(Corpus corpus, String propertie,

			int[] positions) throws CqiClientException {

		return match.getValuesForProperty(corpus.getProperty(propertie),

				positions);

	}

	/**

	 * Match get properties.

	 *

	 * @param corpus the corpus

	 * @param propertie the propertie

	 * @param positions the positions

	 * @return the list

	 * @throws CqiClientException the cqi client exception

	 */

	@SuppressWarnings("static-access") //$NON-NLS-1$

	public List<String> matchGetProperties(Corpus corpus, Property propertie,

			int[] positions) throws CqiClientException {

		return match.getValuesForProperty(propertie, positions);

	}

	/**

	 * Gets the text id.

	 *

	 * @return the text id

	 */

	public Object getTextId() {

		return this.textId;

	}

	/**

	 * Gets the concordance.

	 *

	 * @return the concordance

	 */

	public Concordance getConcordance() {

		return concordance;

	}

	/**

	 * Gets the keyword ids.

	 *

	 * @return the keyword ids

	 */

	public Collection<? extends String> getKeywordIds() {

		return this.keywordsIdValues;

	}

	/**

	 * Gets the keyword position.

	 *

	 * @return the keyword position

	 */

	public int getKeywordPosition() {

		return keywordpos;

	}

	public Annotation getAnnotation() {

		return annotation;

	}

}

// 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: 2014-07-15 09:42:00 +0200 (mar., 15 juil. 2014) $

// $LastChangedRevision: 2820 $

// $LastChangedBy: mdecorde $ 

//

package org.txm.functions.concordances.comparators;

import java.util.HashMap;

import java.util.List;

import org.txm.core.messages.TXMCoreMessages;

import org.txm.functions.concordances.Concordance;

import org.txm.functions.concordances.Line;

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

// TODO: Auto-generated Javadoc

/**

 * Compare two values of left context of a concordance line @ author mdecorde.

 */

public class LexicographicLeftContextComparator extends

		StringListBasedComparator {

	/** The Constant NAME. */

	private static final String NAME = TXMCoreMessages.LexicographicLeftContextComparator_0;

	private Concordance conc;

	private List<Property> props;

	/**

	 * Instantiates a new lexicographic left context comparator.

	 */

	public LexicographicLeftContextComparator() {

		super(NAME);

	}

	/* (non-Javadoc)

	 * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)

	 */

	@Override

	public int compare(Line l1, Line l2) {

		this.conc = l1.getConcordance();

		this.props = conc.getLeftAnalysisProperties();

		if (props.size() == 0)

			return 0;

		int rez = 0;

		int i = 0;

		HashMap<Property, List<String>> values1 = l1.getLeftAnalysisProperty();

		HashMap<Property, List<String>> values2 = l2.getLeftAnalysisProperty();

		int j1 = l1.getLeftAnalysisProperty().get(props.get(0)).size() -1;

		int j2 = l2.getLeftAnalysisProperty().get(props.get(0)).size() -1;

		String v1, v2;

		while (rez == 0) {

			if ((j1 < 0) && (j2 < 0))

				return 0;

			if (j1 < 0)

				return -1; // end of line 1

			if (j2 < 0)

				return 1; // end of line 2

			v1 = values1.get(props.get(i)).get(j1);

			v2 = values2.get(props.get(i)).get(j2);

			if (v1 == null) return -1;

			if (v2 == null) return 1;

			rez = collator.compare(v1, v2);

			if (++i >= props.size()) { // iterates over properties before tokens

				i = 0;

				j1--;

				j2--;

			}

		}

		return rez;

	}

}

// 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: 2013-05-06 17:38:43 +0200 (lun., 06 mai 2013) $

// $LastChangedRevision: 2386 $

// $LastChangedBy: mdecorde $ 

//

package org.txm.functions.concordances.comparators;

import java.util.Iterator;

import java.util.List;

// TODO: Auto-generated Javadoc

/**

 * The Class StringListBasedComparator.

 */

public abstract class StringListBasedComparator extends LocalizedLineComparator {

	/**

	 * Instantiates a new string list based comparator.

	 *

	 * @param name the name

	 */

	StringListBasedComparator(String name) {

		super(name);

	}

	/**

	 * Compare list.

	 *

	 * @param l1 the l1

	 * @param l2 the l2

	 * @return the int

	 */

	protected int compareList(List<String> l1, List<String> l2) {

		Iterator<String> it1 = l1.iterator();

		Iterator<String> it2 = l2.iterator();

		while (it1.hasNext() && it2.hasNext()) {

			int c = collator.compare(it1.next(), it2.next());

			if (c != 0)

				return c;

		}

		if (it1.hasNext())

			return 1; // it2 is a prefix of it1

		if (it2.hasNext())

			return -1; // it1 is a prefix of it2

		return 0;

	}

}

// 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: 2013-05-06 17:38:43 +0200 (lun., 06 mai 2013) $

// $LastChangedRevision: 2386 $

// $LastChangedBy: mdecorde $ 

//

package org.txm.functions.concordances.comparators;

import java.util.List;

import org.txm.core.messages.TXMCoreMessages;

import org.txm.functions.concordances.Line;

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

// TODO: Auto-generated Javadoc

/**

 * The Class CompositeComparator.

 */

public class CompositeComparator extends LineComparator {

	/** The comparators. */

	private List<LineComparator> comparators;

	/**

	 * Instantiates a new composite comparator. A composite comparator C is made

	 * of a list compartors [C0,...,Cn]. C.compare(l1,l2) == 1 (resp. -1) if and

	 * only if their exists k such as Ci.compare(l1,l2)==0 for i<k and

	 * Ck.compare(l1,l2)=1 (resp. -1) C.compare(l1,l2) == 0 if and only if

	 * Ci.compare(l1,l2)==0 for all i

	 *

	 * @param name the name

	 * @param comparators the comparators

	 */

	public CompositeComparator(String name, List<LineComparator> comparators) {

		super(name);

		setComparators(comparators);

	}

	/*public CompositeComparator addComparator(LineComparator comparator) {

		this.comparators.add(comparator);

		return this;

	}*/

	/* (non-Javadoc)

	 * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)

	 */

	@Override

	public int compare(Line l1, Line l2) {

		//System.out.println("compare: "+l1+" "+l2);

		for (LineComparator comparator : comparators) {

			int c = comparator.compare(l1, l2);

			//System.out.println("comparator: "+comparator+" = "+c);

			if (c != 0)

				return c;

		}

		return 0;

	}

	/* (non-Javadoc)

	 * @see org.txm.functions.concordances.comparators.LineComparator#initialize(org.txm.searchengine.cqp.corpus.Corpus)

	 */

	@Override

	public void initialize(Corpus corpus) {

		for (LineComparator comparator : comparators)

			comparator.initialize(corpus);

	}

	/**

	 * Gets the comparators.

	 *

	 * @return the comparators

	 */

	public List<LineComparator> getComparators() {

		return comparators;

	}

	/**

	 * Sets the comparators.

	 *

	 * @param comp the new comparators

	 */

	public void setComparators(List<LineComparator> comp) {

		this.comparators = comp;

		this.name = TXMCoreMessages.CompositeComparator_0;

		for(LineComparator c: comp)

			this.name += c.getName()+" "; //$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.

// 

// 

// 

// $LastChangedDate: 2014-07-15 09:42:00 +0200 (mar., 15 juil. 2014) $

// $LastChangedRevision: 2820 $

// $LastChangedBy: mdecorde $ 

//

package org.txm.functions.concordances.comparators;

import java.util.HashMap;

import java.util.List;

import org.txm.core.messages.TXMCoreMessages;

import org.txm.functions.concordances.Concordance;

import org.txm.functions.concordances.Line;

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

// TODO: Auto-generated Javadoc

/**

 * Compare two values of right context of a concordance line @ author mdecorde.

 */

public class LexicographicRightContextComparator extends

		StringListBasedComparator {

	/** The Constant NAME. */

	private static final String NAME = TXMCoreMessages.LexicographicRightContextComparator_0;

	private Concordance conc;

	private List<Property> props;

	/**

	 * Instantiates a new lexicographic right context comparator.

	 */

	public LexicographicRightContextComparator() {

		super(NAME);

	}

	/* (non-Javadoc)

	 * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)

	 */

	@Override

	public int compare(Line l1, Line l2) {

		int rez = 0;

		int i = 0; // property counter

		int j = 0; // position counter

		HashMap<Property, List<String>> values1 = l1.getRightAnalysisProperty();

		HashMap<Property, List<String>> values2 = l2.getRightAnalysisProperty();

		this.conc = l1.getConcordance();

		this.props = conc.getRightAnalysisProperties();

		List<String> vals1;

		List<String> vals2;

		String v1, v2;

		int size1  = values1.get(props.get(0)).size();

		int size2 = values2.get(props.get(0)).size();

		while (rez == 0) {

//			vals1 = values1.get(props.get(i));

//			vals2 = values2.get(props.get(i));

			//System.out.println("LINE 1: "+vals1);

			//System.out.println("LINE 2: "+vals2);

			if(size1 <= j && size2 <= j)

				return 0; // end of line 1

			if (size1 <= j)

				return -1; // end of line 1

			if (size2 <= j)

				return 1; // end of line 2

			v1 = values1.get(props.get(i)).get(j);

			v2 = values2.get(props.get(i)).get(j);

			//System.out.println("COMP "+j+" : "+v1+" "+v2);

			if (v1 == null) return -1;

			if (v2 == null) return 1;

			rez = collator.compare(v1, v2);

			if (++i >= props.size()) { // iterates over properties before tokens

				i = 0;

				j++;

			}

		}

		return rez;

	}

}

// 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: 2013-05-06 17:38:43 +0200 (lun., 06 mai 2013) $

// $LastChangedRevision: 2386 $

// $LastChangedBy: mdecorde $ 

//

package org.txm.functions.concordances.comparators;

import java.util.HashMap;

import java.util.List;

import org.txm.core.messages.TXMCoreMessages;

import org.txm.functions.concordances.Concordance;

import org.txm.functions.concordances.Line;

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

// TODO: Auto-generated Javadoc

/**

 * Compare two values of keyword of a concordance line 

 * @author mdecorde.

 */

public class LexicographicKeywordComparator extends LocalizedLineComparator {

	/** The Constant NAME. */

	private static final String NAME = TXMCoreMessages.LexicographicKeywordComparator_0;

	private Concordance conc;

	private List<Property> props;

	/**

	 * Instantiates a new lexicographic keyword comparator.

	 */

	public LexicographicKeywordComparator() {

		super(NAME);

	}

	/* (non-Javadoc)

	 * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)

	 */

	@Override

	public int compare(Line l1, Line l2) {

		int rez = 0;

		int i = 0;

		int j = 0;

		HashMap<Property, List<String>> values1 = l1.getKeywordsAnalysisProperty();

		HashMap<Property, List<String>> values2 = l2.getKeywordsAnalysisProperty();

		this.conc = l1.getConcordance();

		this.props = conc.getKeywordAnalysisProperties();

		while(rez == 0) {

			List<String> vals1 = values1.get(props.get(i));

			List<String> vals2 = values2.get(props.get(i));

			if(vals1.size() <= j && vals2.size() <= j)

				return 0; // end of line 1

			if(vals1.size() <= j)

				return -1; // end of line 1

			if(vals2.size() <= j)

				return 1; // end of line 2

			rez = collator.compare(vals1.get(j), vals2.get(j));

			if(++i >= props.size()) { // iterates over properties before tokens

				i = 0;

				j++;

			}

		}

		return rez;

	}

}

<html>

<body>

<p>Sorters for displaying concordance.</p>

</body>

</html>

// 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: 2013-05-06 17:38:43 +0200 (lun., 06 mai 2013) $

// $LastChangedRevision: 2386 $

// $LastChangedBy: mdecorde $ 

//

package org.txm.functions.concordances.comparators;

import java.util.Comparator;

import org.txm.functions.concordances.Line;

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

// TODO: Auto-generated Javadoc

/**

 * Abstract comparator of concordance line @ author mdecorde.

 */

public abstract class LineComparator implements Comparator<Line> {

	/** The name. */

	protected String name;

	/** The available comparator. */

	private static String[] availableComparator = new String[] {

			"org.txm.functions.concordances.comparators.LexicographicKeywordComparator", //$NON-NLS-1$

			"org.txm.functions.concordances.comparators.LexicographicLeftContextComparator", //$NON-NLS-1$

			"org.txm.functions.concordances.comparators.LexicographicRightContextComparator", //$NON-NLS-1$

			"org.txm.functions.concordances.comparators.PropertiesReferenceComparator" //$NON-NLS-1$

	};

	/**

	 * Return the list of all the known comparators. Any non-abstract class

	 * extending LineComparator should be mentionned in the availableComparator

	 * list

	 *

	 * @return the available comparators

	 */

	static public String[] getAvailableComparators() {

		return availableComparator;

	}

	/**

	 * Instantiates a new line comparator.

	 *

	 * @param name the name

	 */

	public LineComparator(String name) {

		this.name = name;

	}

	/**

	 * Gets the name.

	 *

	 * @return the name

	 */

	public String getName() {

		return name;

	}

	/* (non-Javadoc)

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

	 */

	@Override

	public String toString() {

		return "C:" + name; //$NON-NLS-1$

	}

	/**

	 * Initialize.

	 *

	 * @param corpus the corpus

	 */

	public abstract void initialize(Corpus corpus);

}

// 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: 2013-05-06 17:38:43 +0200 (lun., 06 mai 2013) $

// $LastChangedRevision: 2386 $

// $LastChangedBy: mdecorde $ 

//

package org.txm.functions.concordances.comparators;

import org.txm.core.messages.TXMCoreMessages;

import org.txm.functions.concordances.Line;

// TODO: Auto-generated Javadoc

/**

 * return the order of the text.

 *

 * @author mdecorde

 */

public class NullComparator extends LocalizedLineComparator {

	/** The Constant NAME. */