Laboratoire ICAR » Plateforme TXM

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

import org.osgi.service.prefs.Preferences;

			am = new AnnotationManager(corpus);

			am.initialize();

			ams.put(corpus, am);

//	protected static Element getKnowledgeRepositoriesElement(Element corpusElement) {

//		NodeList textsList = corpusElement.getElementsByTagName("knowledgeRepositories");

//		if (textsList.getLength() == 0) {

//			Element knowledgeRepositories = corpusElement.getOwnerDocument().createElement("knowledgeRepositories");

//			corpusElement.appendChild(knowledgeRepositories);

//			return knowledgeRepositories;

//		} else {

//			return (Element) textsList.item(0);

//		}

//	}

	 * @throws BackingStoreException 

	public static KnowledgeRepository getKnowledgeRepository(CQPCorpus corpus, String name) throws BackingStoreException {

	 * @param name the repository name

	 * @return the KR configuration map

	 * @throws BackingStoreException 

	public static HashMap<String, HashMap<String, ?>> getKnowledgeRepositoryConfiguration(String name, Preferences preference) throws BackingStoreException {

		HashMap<String, HashMap<String, ?>> repConfiguration = new HashMap<String, HashMap<String, ?>>();

		HashMap<String, String> access = new HashMap<String, String>();

		HashMap<String, HashMap<String, String>> strings = new HashMap<String, HashMap<String, String>>();

		HashMap<String, HashMap<String, String>> fields = new HashMap<String, HashMap<String, String>>();

		if (preference == null) return null;

		access.put(SQLKnowledgeRepository.NAME, preference.get(SQLKnowledgeRepository.NAME, "default"));

		access.put("version", preference.get("version","0"));

		access.put("mode", preference.get("mode",""));

		access.put(SQLKnowledgeRepository.TYPE_URL, preference.get(SQLKnowledgeRepository.TYPE_URL, ""));

		access.put(SQLKnowledgeRepository.TYPE_RESURL, preference.get(SQLKnowledgeRepository.TYPE_RESURL, ""));

		access.put(SQLKnowledgeRepository.TYPE_TYPEURL, preference.get(SQLKnowledgeRepository.TYPE_TYPEURL, ""));

		access.put(SQLConnection.SQL_ADDRESS, preference.get(SQLConnection.SQL_ADDRESS, ""));

		access.put(SQLConnection.SQL_DRIVER, preference.get(SQLConnection.SQL_DRIVER,""));

		access.put(SQLConnection.SQL_PORT, preference.get(SQLConnection.SQL_PORT,""));

		access.put(SQLConnection.SQL_USER, preference.get(SQLConnection.SQL_USER,""));

		access.put(SQLConnection.SQL_PASSWORD, preference.get(SQLConnection.SQL_PASSWORD,""));

		//<type id="" name> ... </type>

		Preferences typesList = preference.node("type");

		for (String type_id : typesList.childrenNames()) {

			//<field type="xxx">yyy</field>

//			Element typeElement = (Element)typesList.item(i);

//			String type_id = ""+typeElement.getAttribute(SQLKnowledgeRepository.TYPE_ID);

			Preferences typeElement = typesList.node(type_id);

			String type_name = typeElement.get(SQLKnowledgeRepository.NAME, type_id);

			String type_url = ""+typeElement.get(SQLKnowledgeRepository.TYPE_URL, "");

			String type_size = typeElement.get(SQLKnowledgeRepository.TYPE_SIZE, "SMALL");

			type_size = type_size.toUpperCase();

			String type_effect = typeElement.get(SQLKnowledgeRepository.TYPE_EFFECT, "SEGMENT");

			type_effect = type_effect.toUpperCase();

			HashMap<String, String> hashFields = new HashMap<String, String>();

			Preferences fieldsList = typeElement.node("field"); // contains KR type specific properties

			for (String field_type : fieldsList.keys()) {

				hashFields.put(field_type, fieldsList.get(field_type, ""));

			}

			hashFields.put(SQLKnowledgeRepository.TYPE_URL, type_url);

			hashFields.put(SQLKnowledgeRepository.NAME, type_name);

			hashFields.put(SQLKnowledgeRepository.TYPE_SIZE, type_size);

			hashFields.put(SQLKnowledgeRepository.TYPE_EFFECT, type_effect);

			fields.put(type_id, hashFields);

		Preferences stringsList = preference.node("strings");

		for (String lang : stringsList.childrenNames()) {

			Preferences stringsElement = stringsList.node(lang);

//			String lang = stringsElement.getAttribute("lang");

//			if (lang == null) lang = "en"; // default lang is "en"

			HashMap<String, String> values = new HashMap<String, String>();

			strings.put(lang, values);

			for (String key : stringsElement.keys()) {

				values.put(key, stringsElement.get(key, ""));

			}

		}

		repConfiguration.put(KNOWLEDGE_ACCESS, access);

		repConfiguration.put(KNOWLEDGE_TYPES, fields);

		repConfiguration.put(KNOWLEDGE_STRINGS, strings);

		return repConfiguration;

//	public static Element getKnowledgeRepositoryElement(BaseOldParameters params, String name) {

//		Element rElement = getKnowledgeRepositoriesElement(params.getCorpusElement());

//		NodeList repositoriesList = rElement.getElementsByTagName("repository");

//		for (int i = 0 ; i < repositoriesList.getLength() ; i++) {

//			Element e = ((Element)repositoriesList.item(i));

//			if (name.equals(e.getAttribute("name"))) {

//				return e;

//			}

//		}

//

//		return null;

//	}

//	/**

//	 * Utility method to get a knowledge repository configuration

//	 * 

//	 * @param params

//	 * @return the repository names

//	 */

//	public static List<String> getKnowledgeRepositoryNames(BaseOldParameters params) {

//		ArrayList<String> names = new ArrayList<String>();

//		Element corpusElement = params.getCorpusElement();

//		if (corpusElement == null) return names;

//

//		Element rElement = getKnowledgeRepositoriesElement(corpusElement);

//		if (rElement == null) return names;

//

//		NodeList repositoriesList = rElement.getElementsByTagName("repository");

//		for (int i = 0 ; i < repositoriesList.getLength() ; i++) {

//			names.add(((Element)repositoriesList.item(i)).getAttribute("name"));

//		}

//

//		if (names.size() == 0) names.add(params.getCorpusName()); // add default KR = properties & structure properties

//		return names;

//	}

	 * @return the repository names the corpus is using

			IEclipsePreferences node = base.getPreferencesScope().getNode("KnowledgeRepository");

			if (!node.nodeExists("DEFAULT")) {

				// create the "DEFAULT" KR configuration

				Preferences krconf = node.node("DEFAULT");

				krconf.put("name", "DEFAULT");

				//

			}

			names = node.childrenNames();

//	public static Element createKnowledgeRepositoryElement(BaseOldParameters params, String name) {

//		Element rElement = getKnowledgeRepositoriesElement(params.getCorpusElement());

//		Element e = rElement.getOwnerDocument().createElement("repository");

//		e.setAttribute("name", name);

//		e.setAttribute("mode", "file");

//		e.setAttribute("user", "false");

//		e.setAttribute("password", "false");

//		e.setAttribute("version", "0");

//

//		rElement.appendChild(e);

//		return e;

//	}

		ams = new HashMap<MainCorpus, AnnotationManager>();

		ams.clear();

import org.osgi.service.prefs.BackingStoreException;

import org.osgi.service.prefs.Preferences;

import org.txm.objects.Project;

	/**

	 * Lazy load KR.

	 * 

	 * @param name

	 * @param conf

	 * @return

	 * @throws BackingStoreException 

	 */

	@SuppressWarnings("unchecked")

	public static KnowledgeRepository createKnowledgeRepository(String name, Preferences preferences) throws BackingStoreException {

		HashMap<String, HashMap<String, ?>> conf = KRAnnotationEngine.getKnowledgeRepositoryConfiguration(name, preferences);

		return createKnowledgeRepository(name, conf);

	}

	 * @throws BackingStoreException 

	public static KnowledgeRepository getKnowledgeRepository(String name, MainCorpus corpus) throws BackingStoreException {

		if (repositories.containsKey(name)) { // kr already loaded

		// test if the corpus has a new configuration for this KR

		Project project = corpus.getProject();

		Preferences corpusprefkrconf = project.getPreferencesScope().getNode("KnowledgeRepository").node(name);

		String sKRCorpusVersion = corpusprefkrconf.get("version", "0");

				KnowledgeRepository krNew = createKnowledgeRepository(name, corpusprefkrconf);

				try { // write the new configuration file in krconf File

					krNew.saveConfiguration(krconf);

			KnowledgeRepository krNew = createKnowledgeRepository(name, corpusprefkrconf);

			if (krNew != null) {

				repositories.put(name, krNew);

				kr = krNew;

			} else {

				System.out.println("Internal error: the new KR is null: "+name);

				return null;

			}

				krNew.saveConfiguration(krconf);

		KnowledgeRepository kr;

		try {

			kr = getKnowledgeRepository(kr_name, corpus);

		} catch (BackingStoreException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

			return KnowledgeRepository.FALSES;

		}

import java.io.File;

	public void saveConfiguration(File krconf) {

		// TODO Auto-generated method stub

	}

import org.osgi.service.prefs.BackingStoreException;

	public AnnotationWriter(MainCorpus corpus) throws BackingStoreException{

	 * @throws BackingStoreException 

	public boolean writeAnnotations(List<Annotation> allCorpusAnnotations) throws IOException, CqiServerError, CqiClientException, InvalidCqpIdException, XMLStreamException, BackingStoreException{

import org.osgi.service.prefs.BackingStoreException;

				KnowledgeRepository kr;

				try {

					kr = KRAnnotationEngine.getKnowledgeRepository(corpus, kr_name);

					if (kr == null) continue;

					List<AnnotationType> types = kr.getAllAnnotationTypes();

					for (AnnotationType t : types) {

						StructuralUnit su = corpus.getStructuralUnit(t.getId().toLowerCase());

						if (su != null) {

							StructuralUnitProperty sup = su.getProperty(REF);

							if (sup != null) {

								supList.put(sup, t);

							}

				} catch (BackingStoreException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

			// needsFullRecomputing == true && isDirtyFromHistory == true && isDirty == true

			// TODO THIS IS FUCKING LAZY LINE CODES OH YEAH YOU MAD BRO

	public ___Lexicon2(CQPCorpus parent)	{

// 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-10-21 11:09:43 +0200 (Fri, 21 Oct 2016) $

// $LastChangedRevision: 3323 $

// $LastChangedBy: mdecorde $ 

//

package org.txm.index.core.functions;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStreamWriter;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.HashMap;

import java.util.LinkedHashMap;

import java.util.List;

import org.eclipse.osgi.util.NLS;

import org.rosuda.REngine.REXPMismatchException;

import org.txm.core.preferences.TXMPreferences;

import org.txm.core.results.Parameter;

import org.txm.core.results.TXMParameters;

import org.txm.core.results.TXMResult;

import org.txm.index.core.functions.LineComparator.SortMode;

import org.txm.index.core.messages.IndexCoreMessages;

import org.txm.index.core.preferences.IndexPreferences;

import org.txm.searchengine.core.Match;

import org.txm.searchengine.core.Query;

import org.txm.searchengine.core.Selection;

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

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

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

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

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

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

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

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

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

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;

/**

 * Computes an index of a corpus or a partition. 

 * 

 * @author mdecorde

 */

public class PartitionIndex extends TXMResult  {

	/** The counts. */

	protected LinkedHashMap<String, ArrayList<Integer>> counts = new LinkedHashMap<String, ArrayList<Integer>>();

	/** The currentpartid. */

	protected int currentpartid = 0;

	/** The current Fmax value. */

	protected int Fmax = 0;

	/** The current Fmin value. */

	protected int Fmin = 9999999;

	/** The lexicon used to compute the index (if query = null || query == [] && properties.size() == 1 */

	@Deprecated

	protected Lexicon lexicon;

	@Deprecated

	protected boolean lexiconMode = false;

	/** The current lines. */

	protected List<Line> lines = new ArrayList<Line>();

	/** The current number of lines. */

	protected int nTotalTokens = 0;

	/** The partnames. The corpus name if built with a Corpus or the parts names if built with a Partition */

	protected List<String> partnames = new ArrayList<String>();

	/** The writer. */

	// FIXME: should be in an exporter extension

	@Deprecated

	private BufferedWriter writer;

	/**

	 * Maximum frequency filter value.

	 */

	@Parameter(key=TXMPreferences.F_MAX)

	protected Integer pFmaxFilter;

	/**

	 * Minimum frequency filter value.

	 */

	@Parameter(key=TXMPreferences.F_MIN)

	protected Integer pFminFilter;

	/**

	 * Number of lines to display per page.

	 */

	@Parameter(key=TXMPreferences.N_LINES_PER_PAGE)

	protected Integer pNLinesPerPage;

	/**

	 * The word properties to display.

	 */

	@Parameter(key=TXMPreferences.UNIT_PROPERTIES)

	protected List<WordProperty> pProperties;

	/**

	 * The string used to separated property values.

	 */

	@Parameter(key=IndexPreferences.PROPERTIES_SEPARATOR)

	protected String pPropertiesSeparator;

	/**

	 * The CQP query.

	 */

	@Parameter(key=TXMPreferences.QUERY)

	protected Query pQuery;

	/**

	 * The line index of the current index page.

	 */

	@Parameter(key=IndexPreferences.N_TOP_INDEX)

	private Integer pTopIndex;

	/**

	 * The vmax filter value parameter.

	 */

	@Parameter(key=TXMPreferences.V_MAX)

	protected Integer pVmaxFilter;

	/**

	 * 

	 * @param parent

	 */

	public PartitionIndex(Partition parent) {

		super(parent);

	}

	/**

	 * 

	 * @param parametersNodePath

	 */

	public PartitionIndex(String parametersNodePath)	{

		super(parametersNodePath);

	}

	@Override

	protected boolean _compute() throws Exception {

		lines.clear();

		counts.clear();

		partnames.clear();

		currentpartid = 0;

		nTotalTokens = 0;

		Partition partition = (Partition)parent;

		for (Part part : partition.getParts()) {

			scanCorpus(part);

			currentpartid++;

			partnames.add(part.getName());

		}

		setLineCounts();

		getAllLines();

		this.filterLines();

		this.subTask("Sorting...");

		this.sortLines(SortMode.FREQUNIT, true);

		this.cut();

		this.dirty = false;

		this.pTopIndex = 0;

		this.subTask("Index done.");

		return true;

	}

	/**

	 * Creates a CQL query string from the specified Index lines.

	 *

	 * @param lines

	 * @return the query

	 */

	public static String createQuery(List<Line> lines) {

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

		if (lines.size() == 0) {

			return query;

		}

		Line line = lines.get(0);

		int nbToken = line.getUnitsProperties().get(0).size();

		int nbProps = line.getProperties().size();

		int nbLines = lines.size();

		List<Property> props = line.getProperties();

		for (int t = 0; t < nbToken; t++) {

			query += "["; //$NON-NLS-1$

			for (int p = 0; p < nbProps; p++) {

				if (props.get(p) instanceof StructuralUnitProperty) {

					query += "_."+((StructuralUnitProperty)props.get(p)).getFullName() + "=\""; //$NON-NLS-1$ //$NON-NLS-2$

				}

				else {

					query += props.get(p) + "=\""; //$NON-NLS-1$

				}

				for (int l = 0; l < nbLines; l++) {

					line = lines.get(l);

					List<List<String>> values = line.getUnitsProperties();

					String s = values.get(p).get(t);

					s = CQLQuery.addBackSlash(s);

					query += s + "|"; //$NON-NLS-1$

				}

				query = query.substring(0, query.length() - 1);

				query += "\" & "; //$NON-NLS-1$

			}

			query = query.substring(0, query.length() - 3);

			query += "] "; //$NON-NLS-1$

		}

		query = query.substring(0, query.length() - 1);

		return query;

	}

	/**

	 * Creates a Query list from the specified Index lines.

	 * @param lines

	 * @return

	 */

	public static List<CQLQuery> createQueries(List<Line> lines) {

		List<CQLQuery> queries = new ArrayList<CQLQuery>();

		for (Line line : lines) {

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

			int nbToken = line.getUnitsProperties().get(0).size();

			int nbProps = line.getProperties().size();

			List<List<String>> values = line.getUnitsProperties();

			List<Property> props = line.getProperties();

			for (int t = 0; t < nbToken; t++) {

				query += "["; //$NON-NLS-1$

				for (int p = 0; p < nbProps; p++) {

					query += props.get(p).getName() + "=\""; //$NON-NLS-1$

					String s = values.get(p).get(t);

					s = CQLQuery.addBackSlash(s);

					query += s;

					query += "\" & "; //$NON-NLS-1$

				}

				query = query.substring(0, query.length() - 3);

				query += "] "; //$NON-NLS-1$

			}

			queries.add(new CQLQuery(query));

		}

		return queries;

	}

	/**

	 * This method alter the index first column frequencies using a table stored in the R workspace

	 * 

	 * @param referenceCorpus the R table variable name

	 * @return true if frequencies have been altered

	 * 

	 * @throws RWorkspaceException

	 * @throws REXPMismatchException

	 */

	public boolean alterFrequencies(String referenceCorpus) throws RWorkspaceException, REXPMismatchException {

		String[] ref_forms = RWorkspace.getRWorkspaceInstance().eval("rownames("+referenceCorpus+")").asStrings(); //$NON-NLS-1$ //$NON-NLS-2$

		int[] ref_freqs = RWorkspace.getRWorkspaceInstance().eval(referenceCorpus+"[,1]").asIntegers(); //$NON-NLS-1$

		if (ref_forms.length != ref_freqs.length) {

			System.out.println("Cannot alter index frequencies with the '"+referenceCorpus+"' empty table.");

			return false;

		}

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

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

			ref_counts.put(ref_forms[i], ref_freqs[i]);

		}

		for (org.txm.index.core.functions.Line l : this.getAllLines()) {

			String key = l.toString();

			if (ref_counts.containsKey(key)) {

				int[] f = {ref_counts.get(key)};

				l.setCounts(f, 0);

			}

		}

		this.updateFminFmax();

		return true;

		//voc.toTxt(new File("/home/mdecorde/TEMP/after.tsv"), "UTF-8", "\t", "");

	}

	@Override

	public boolean canCompute() {

		if (getCorpus() == null && getPartition() == null) {

			Log.severe("Corpus or partition not set."); //$NON-NLS-1$

			return false;

		}

		if (pProperties == null || pProperties.size() == 0) {

			Log.severe("No property set."); //$NON-NLS-1$

			return false;

		}

		if (pQuery == null || pQuery.getQueryString().length() == 0) {

			Log.severe("No query set."); //$NON-NLS-1$

			return false;

		}

		return true;

	}

	@Override

	public boolean saveParameters() {

		this.saveParameter(TXMPreferences.UNIT_PROPERTIES, WordProperty.propertiesToString(pProperties));

		if (pQuery != null) {

			this.saveParameter(TXMPreferences.QUERY, pQuery.getQueryString());

		}

		return true;

	}

	@Override

	public boolean loadParameters() {

		this.pProperties = (List<WordProperty>) Property.stringToProperties(getCorpus(), this.getStringParameterValue(TXMPreferences.UNIT_PROPERTIES));

		this.pQuery = new CQLQuery(this.getStringParameterValue(TXMPreferences.QUERY));

		return true;

	}

	@Override

	public void clean() {

		try {

			if (this.writer != null) {

				this.writer.flush();

				this.writer.close();

			}

		} catch (IOException e) {

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

		}

	}

	/**

	 * keep the vmax lines more frequents.

	 *

	 */

	public void cut() {

		if (pVmaxFilter == null) {

			return;

		}

		this.acquireSemaphore();

		Log.info("Cutting Tmax="+pVmaxFilter);

		// assume the lines are sorted

		//int before = lines.size();

		this.lines = this.lines.subList(0, Math.min(lines.size(), pVmaxFilter));

		this.updateFminFmax();

		this.releaseSemaphore();

	}

	/**

	 * Equals.

	 *

	 * @param index the index

	 * @return true, if successful

	 */

	public boolean equals(PartitionIndex index) {

		try {

			return this.pQuery.equals(index.getQuery())

					&& this.pProperties.equals(index.getProperties())

					&& this.pFminFilter == index.getFilterFmin()

					&& this.pFmaxFilter == index.getFilterFmax();

		}

		catch(Exception e) {

		}

		return false;

	}

	/**

	 * Removes lines with frequency not in [Fmin,Fmax] range.

	 *

	 **/

	public void filterLines() {

		if (!(pFminFilter > 0 && pFmaxFilter > 0 && pFminFilter <= pFmaxFilter)) {

			return;

		}

		Log.info("Filtering Fmin = " + pFminFilter + " and Fmax = " + pFmaxFilter); //$NON-NLS-1$  //$NON-NLS-2$

		for (int i = 0; i < lines.size(); i++) { // for each line

			Line line = lines.get(i);

			int f = line.getFrequency();

			if (f < pFminFilter) { // if its frequency is not in the interval, remove it

				nTotalTokens -= line.getFrequency();

				lines.remove(i);

				i--;

				continue; // no need to go further the line is removed

			}

			if (f > pFmaxFilter) { // if its frequency is not in the interval, remove it

				nTotalTokens -= line.getFrequency();

				lines.remove(i);

				i--;

			}

		}

		this.updateFminFmax();

	}

	/**

	 * Gets the corpus.

	 *

	 * @return the corpus

	 */

	public CQPCorpus getCorpus() {

		if (this.parent instanceof CQPCorpus) {

			return (CQPCorpus) this.parent;

		} else if (this.parent instanceof Partition) {

			return ((Partition)this.parent).getParent();

		} else if (this.lexicon != null) {

			return this.lexicon.getParent();

		} else {

			return null;

		}

	}

	@Override

	public String getDetails() {

		if (lexicon != null) {

			return lexicon.getDetails();

		} else {

			try {

				Object[] params = new Object[]{this.parent.getSimpleName(), this.getQuery().getQueryString(), this.getProperties(), this.getFmin(), this.getFmax()}; 

				String str;

				if(this.parent instanceof Partition)	{

					str = IndexCoreMessages.DetailsFromPartition;

				}

				else	{

					str = IndexCoreMessages.DetailsFromCorpus;

				}

				return NLS.bind(str, params);

			}

			catch(Exception e) {

				return getName();

			}

		}

	}

	/**

	 * Gets the filter fmax.

	 *

	 * @return the filter fmax

	 */

	public Integer getFilterFmax() {

		return pFmaxFilter;

	}

	/**

	 * Gets the filter fmin.

	 *

	 * @return the filter fmin

	 */

	public Integer getFilterFmin() {

		return pFminFilter;

	}

	/**

	 * Gets the filter vmax.

	 *

	 * @return the filter vmax

	 */

	public Integer getFilterVmax() {

		return pVmaxFilter;

	}

	/**

	 * Gets the fmax.

	 *

	 * @return the fmax

	 */

	public int getFmax() {

		return Fmax;

	}

	/**

	 * Gets the fmin.

	 *

	 * @return the fmin

	 */

	public int getFmin() {

		return Fmin;

	}

	/**

	 * If the index has been build with corpus + property, the method returns the lexicon used.

	 *

	 * @return the lexicon

	 */

	public Lexicon getLexicon() {

		return lexicon;

	}

	public boolean getLexiconMode() {

		return this.lexiconMode;

	}

	/**

	 * return the lines from le "start"th one to the "end"th one.

	 *

	 * @param start the start

	 * @param end the end

	 * @return the lines

	 */

	public List<Line> getLines(int start, int end) {

		//	long time = System.currentTimeMillis();

		List<Line> selectedLines = new ArrayList<Line>();

		if (lines.size() > 0) {

			start = Math.max(0, start);

			end = Math.min(end, lines.size());

			selectedLines = lines.subList(start, end);

			int p = 0;

			// for each property get the string values of the tokens

			for (Property property : pProperties) {

				int len = 0;

				for (Line l : selectedLines) {

					len += l.UnitsIds.get(p).length;

				}

				int[] indices = new int[len]; // build the array of indices

				len = 0;

				for (Line l : selectedLines) {

					int[] ids = l.UnitsIds.get(p);

					System.arraycopy(ids, 0, indices, len, ids.length);

					len += ids.length;

				}

				String[] strs = null;

				try {

					if (property instanceof StructuralUnitProperty) {

						strs = CorpusManager.getCorpusManager().getCqiClient().struc2Str(property.getQualifiedName(), indices);

					}

					else {

						strs = CorpusManager.getCorpusManager().getCqiClient().id2Str(property.getQualifiedName(), indices);

					}

				} catch (Exception e) {

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

					return null;

				}

				len = 0;

				for (Line l : selectedLines) {

					int[] ids = l.UnitsIds.get(p);

					String[] lstr = new String[ids.length];

					System.arraycopy(strs, len, lstr, 0, ids.length);

					if (l.UnitsProperty.size() == pProperties.size()) continue; // the line is already initialized

					l.put(property, Arrays.asList(lstr));

					len += ids.length;

				}

				p++;

			}

		}

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

		return selectedLines;

	}

	/**

	 * return all the lines of the index.

	 *

	 * @return the all lines

	 */

	public List<Line> getAllLines() {

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

	}

	/**

	 * update the lines counts.

	 */

	protected void setLineCounts() {

		for (Line line : lines) {// for each Line set its count

			int[] c = new int[partnames.size()];

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

				if (counts.get(line.getSignature()).size() <= i) {

					c[i] = 0;

				}

				else {

					c[i] = counts.get(line.getSignature()).get(i);

				}

			}

			line.setCounts(c, -1);

		}

	}

	@Override

	public String getName() {

		try {

			if (lexicon != null) {

				return lexicon.getName();

			}

			else {

				return IndexCoreMessages.RESULT_TYPE + ": " + this.parent.getSimpleName() + ": " + this.getSimpleName();

			}

		}

		catch(Exception e) {

			return this.getEmptyName();

		}

	}

	/**

	 * Gets the number of lines per page.

	 * @return the number of lines per page

	 */

	public Integer getNLinesPerPage() {

		return pNLinesPerPage ;

	}

	/**

	 * Gets the partition.

	 *

	 * @return the partition if exists otherwise null

	 */

	public Partition getPartition() {

		try {

			return (Partition) this.parent;

		}

		catch(ClassCastException e) {

		}

		return null;

	}

	/**

	 * Gets the part names.

	 *

	 * @return the part names

	 */

	public List<String> getPartnames() {

		return partnames;

	}

	/**

	 * Gets the properties.

	 *

	 * @return the properties

	 */

	public List<WordProperty> getProperties() {

		return this.pProperties;

	}

	/**

	 * 

	 * @return

	 */

	public String getPropertySeparator() {

		return pPropertiesSeparator ;

	}

	/**

	 * Gets the query.

	 *

	 * @return the query used

	 */

	public Query getQuery() {

		return pQuery;

	}

	@Override

	public String getSimpleName() {

		if (lexicon != null) {

			return lexicon.getSimpleName();

		}

		else {

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

			if (pQuery != null && !pQuery.isEmpty()) {

				name += pQuery.getQueryString();

				name += ": "; //$NON-NLS-1$

				for (Property s : pProperties) {

					name += s.getName() + pPropertiesSeparator;

				}

				if (pProperties.size() > 0) {

					name = name.substring(0, name.length() - 1);

				}

				return name;

			}

			else {

				return this.getEmptyName();

			}

		}

	}

	/**

	 * Gets the number of tokens found.

	 *

	 * @return the number of tokens returned by the selection

	 */

	public int getT() {

		return nTotalTokens;

	}

	/**

	 * 

	 * @return

	 */

	public int getTopIndex() {

		return pTopIndex;

	}

	/**

	 * Gets the v.

	 *

	 * @return the number of entries in the index

	 */

	public int getV() {

		return lines.size();

	}

	/**

	 * Tell if the index has been computed with a partition or not.

	 *

	 * @return true, if is computed with partition

	 */

	public boolean isComputedWithPartition() {

		return (this.getParent() instanceof Partition);

	}

	/**

	 * count tokens.

	 *

	 * @param corpus the corpus to scan

	 * @return true, if successful

	 * @throws CqiClientException 

	 * @throws CqiServerError 

	 * @throws IOException 

	 */

	protected boolean scanCorpus(CQPCorpus corpus) throws Exception {

		// get the cqp result of the query

		//long time = System.currentTimeMillis();

		Selection result = null;

		if (pQuery instanceof CQLQuery) {

			result = corpus.query((CQLQuery)pQuery, "index", true); //$NON-NLS-1$

		} else {

			result = pQuery.getSearchEngine().query(corpus, pQuery, "index", true); //$NON-NLS-1$

		}

		boolean isTargetUsed = result.isTargetUsed();

		int nbresults = result.getNMatch();

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

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

		List<? extends Match> matches = null;

		if (nbresults > 0) {

			matches = result.getMatches(0, nbresults - 1); // get the indexes sequences of result's tokens

		}

		else {

			matches = new ArrayList<Match>();

		}

		// 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);

				}

			}

		}

		// System.out.println("get string data");

		// time = System.currentTimeMillis();

		// for (Property property : props) {// for each property get the

		// string values of the tokens

		// keywordsViewPropValues.put(property,

		// cache.get(property).getData(beginingOfKeywordsPositions,

		// lengthOfKeywords));

		// }

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

		// System.out.println("get count data");