Laboratoire ICAR » Plateforme TXM

		deleteLineButton.setImage(IImageKeys.getImage(IImageKeys.ACTION_DELETE));

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

	private CQPLexicon lexicon;

	private CQPLexicon subLexicon;

	public CQPLexicon getLexicon() {

			File temp = new File(xmlfile.getAbsolutePath()+"-rez.xml");

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

			metadatas.put("name1", "tricky value\"");

			metadatas.put("name2", "value&2");

			metadatas.put("name3", "value<3");

			metadatas.put("name4", "value>");

			AddAttributeInXml builder = new AddAttributeInXml(xmlfile, tag, metadatas);

			builder.onlyOneElement();

			if (builder.process(temp)) {

				System.out.println("Done: ok.");

			} else {

				System.out.println("Error during process");

			}

import java.util.ArrayList;

import java.util.HashMap;

										output.write(" "+attrname+"=\""+parser.getAttributeValue(i).replace("&", "&").replace("\"", """)+"\"" );

import java.util.TreeSet;

		List<Field> fields = this.getAllFields();

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

			// CQP Lexicon

			CQPLexicon lex1 = new CQPLexicon(corpus);

			lex1._compute();

		println "Tokenize=$tokenize sentence=$sentence"

boolean doTokenizeStep = project.getDoTokenizerStep()

imp.doTokenize(doTokenizeStep) // change this, to not tokenize xml

									String attrvalue = parser.getAttributeValue(i).replaceAll("\"", """)

									output.write(" "+attrname.toLowerCase()+"=\""+attrvalue.replaceAll("\"", """)+"\"")

cqpFile.delete()

cqpFile.delete()

cqpFile.delete()

		cqpFile.delete()

cqpFile.delete()

cqpFile.delete()

cqpFile.delete()

		allcqpFile.delete()

	boolean doTokenizeStep = false;

		this.doTokenizeStep = project.getDoTokenizerStep()

		if (doTokenizeStep) {

cqpFile.delete()

cqpFile.delete()

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

import org.txm.index.rcp.editors.LexiconEditor;

		Lexicon index = null;

			index = new Lexicon(corpus);

		// Reopening an existing Lexicon

		else if(selection instanceof Lexicon) { 

			index = (Lexicon) selection;

		}

		TXMEditor.openEditor(lexicon, LexiconEditor.class.getName());

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

// Copyright © 2010-2013 ENS de Lyon.

package org.txm.index.rcp.editors;

import org.eclipse.swt.layout.GridData;

/**

 * Extends the index editor to:

 * - set the number of property to 1 

 * - hide the query field

 * 

 *  @author mdecorde.

 */

public class LexiconEditor extends IndexEditor {

	@Override

	public void _createPartControl() {

		super._createPartControl();

		this.propertiesSelector.setMaxPropertyNumber(1);

		this.queryWidget.setText("[]"); //$NON-NLS-1$

		this.queryWidget.setEnabled(false);

		this.queryWidget.setVisible(false);

		this.queryWidget.setSize(0, 0);

		this.queryWidget.setLayoutData(new GridData(0, 0));

		//this.queryWidget.dispose();

		this.queryLabel.setVisible(false);

		this.queryLabel.dispose();

		// no query field -> no need to expand the zone

		getMainParametersComposite().setLayoutData(new GridData(GridData.FILL, GridData.FILL, false, false));

	}

}

		setFocus();

		if (this.queryWidget != null && !this.queryWidget.isDisposed()) {

            class="org.txm.index.rcp.editors.LexiconEditor"

            id="org.txm.index.rcp.editors.LexiconEditor"

            name="%command.name.0"

            returnTypeId="org.txm.index.core.functions.Lexicon">

                  value="org.txm.index.rcp.editors.LexiconEditor">

// 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-09-19 10:31:00 +0200 (Mon, 19 Sep 2016) $

// $LastChangedRevision: 3298 $

// $LastChangedBy: mdecorde $ 

//

package org.txm.searchengine.cqp.corpus;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStreamWriter;

import java.io.UnsupportedEncodingException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.Map;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.osgi.util.NLS;

import org.txm.Toolbox;

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.searchengine.cqp.AbstractCqiClient;

import org.txm.searchengine.cqp.ICqiClient;

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

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

//import org.txm.statsengine.core.StatException;

//import org.txm.statsengine.core.data.Vector;

//import org.txm.statsengine.r.core.data.VectorImpl;

import org.txm.utils.logger.Log;

//  TODO should be put into stat.data package ?

/**

 * Represent a frequency list according to a {@link CQPCorpus} (or a.

 *

 * {@link Subcorpus}) and a {@link Property}.

 * @author sloiseau

 */

public class CQPLexicon {

	/** The forms. */

	private String[] forms;

	/** The freqs. */

	private int[] freqs;

	/** The ids. */

	private int[] ids;

	/** The number of tokens. */

	int numberOfTokens = -1;

	/** The symbol. */

	private String symbol;

	/** The writer. */

	private OutputStreamWriter writer;

	/**

	 * The property.

	 */

	protected Property pProperty;

	private CQPCorpus corpus;

	/**

	 * @param corpus

	 */

	public CQPLexicon(CQPCorpus corpus)	{

		this.corpus = corpus;

	}

	public boolean _compute() throws Exception {

		if (this.getParent() instanceof MainCorpus) {

			return computeWithMainCorpus((MainCorpus)this.getParent(), pProperty, null);

		}

		else if (this.getParent() instanceof Subcorpus) {

			return computewithSubCorpus((Subcorpus)this.getParent(), pProperty, null);

		}

		else {

			Log.severe("Error: Lexicon parent is neither a Maincorpus nor a Subcorpus."); //$NON-NLS-1$

			return false;

		}

	}

	/**

	 * Gets the lexicon relative to a given property.

	 * 

	 * @param property

	 *            the property

	 * 

	 * @return the lexicon

	 * 

	 * @throws CqiClientException

	 *             the cqi client exception

	 */

	protected boolean computeWithMainCorpus(MainCorpus corpus, Property property, IProgressMonitor monitor) throws CqiClientException {

		// System.out.println("in "+this.getCqpId()+" look for cached lexicon "+property);

		// System.out.println("not found");

		int lexiconSize;

		try {

			lexiconSize = CorpusManager.getCorpusManager().getCqiClient().lexiconSize(property.getQualifiedName());

		} catch (Exception e) {

			throw new CqiClientException(e);

		}

		int[] ids = new int[lexiconSize];

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

			ids[i] = i;

		}

		int[] freqs;

		try {

			freqs = CorpusManager.getCorpusManager().getCqiClient().id2Freq(property.getQualifiedName(), ids);

		} catch (Exception e) {

			throw new CqiClientException(e);

		}

		this.init(corpus, property, freqs, ids);

		return true;

	}

	/**

	 * 

	 * @param corpus

	 * @param property

	 * @param monitor

	 * @return

	 * @throws CqiClientException

	 */

	// FIXME: why this method needs to create and delete some new subcorpus???? the computing can't be done directly on the corpus argument???

	// eg. dist = CorpusManager.getCorpusManager().getCqiClient().fdist1(corpus.getQualifiedCqpId(), 0,	ICqiClient.CQI_CONST_FIELD_MATCH, property.getName());

	protected boolean computewithSubCorpus(Subcorpus corpus, Property property, IProgressMonitor monitor) throws CqiClientException {

		//System.out.println("not found");

//		Log.finest(NLS.bind(IndexCoreMessages.computingTheLexiconOfSubcorpusP0, corpus.getName()));

		//long start = System.currentTimeMillis();

		int[][] fdist = null;

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

		String tmp = "TMP" + CQPCorpus.getNextSubcorpusCounter();

		String qtmp = corpus.getMainCorpus().getQualifiedCqpId()+":"+tmp;

		try {

			System.out.println("subcorpus: "+corpus.getQualifiedCqpId());

			System.out.println("query subcorpus: "+qtmp);

			cqi.cqpQuery(corpus.getQualifiedCqpId(), tmp, "[]");

			fdist = CorpusManager.getCorpusManager().getCqiClient().fdist1(qtmp, 0, ICqiClient.CQI_CONST_FIELD_MATCH, property.getName());

			//System.out.println("nb lines: "+fdist.length);

		} catch (Exception e) {

			throw new CqiClientException(e);

		} finally {

			try {

				cqi.dropSubCorpus(qtmp);

			} catch (IOException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			} catch (CqiServerError e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

		}

		int lexiconSize = fdist.length;

		int[] freqs = new int[lexiconSize];

		int[] ids = new int[lexiconSize];

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

			ids[i] = fdist[i][0];

			freqs[i] = fdist[i][1];

		}

		init(corpus, property, freqs, ids);

		return true;

	}

	/**

	 * Compute number of tokens. / this.nbr

	 */

	private void computeNumberOfTokens() {

		numberOfTokens = 0;

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

			numberOfTokens += freqs[i];

			// System.out.println(numberOfTokens);

			// if (freqs[i] != 1) System.out.println(freqs[i]);

		}

	}

	/**

	 * Dump lexicon forms and frequencies in a String.

	 *

	 * @param col the col

	 * @param txt the txt

	 * @return the string

	 */

	public String dump(String col, String txt) {

		StringBuffer buffer = new StringBuffer();

		getForms();

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

			buffer.append(txt + forms[i].replace(txt, txt + txt) + txt + col + freqs[i] + "\n"); //$NON-NLS-1$ 

		}

		return buffer.toString();

	}

	/* (non-Javadoc)

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

	 */

	@Override

	public boolean equals(Object obj) {

		if (!(obj instanceof CQPLexicon)) {

			return false;

		}

		CQPLexicon other = (CQPLexicon) obj;

		if (other.nbrOfType() != this.nbrOfType()) {

			return false;

		}

		return (Arrays.equals(freqs, other.getFreq()) && Arrays.equals(getForms(), other.getForms()));

	}

	/**

	 * The corpus or subcorpus this lexicon is build on.

	 * 

	 * @return the corpus

	 */

	public CQPCorpus getCorpus() {

		return corpus;

	}

	public String getDetails() {

			return this.getParent().getName() + " " + this.pProperty.getName(); //$NON-NLS-1$

	}

	//TODO: move this into a Lexicon chart renderer

	//	/**

	//	 * Draw a pareto graphic with this frequency list and record it into the

	//	 * provided filename into svg format.

	//	 *

	//	 * @param file where to save the pareto graphic.

	//	 * @return the pareto graphic

	//	 * @throws StatException if anything goes wrong.

	//	 */

	//	public void getParetoGraphic(File file) throws StatException {

	//		String rName = asVector().getSymbol();

	//		String expr = "pareto(" + rName + ")"; //$NON-NLS-1$ //$NON-NLS-2$

	//		try {

	//			RWorkspace.getRWorkspaceInstance().plot(file, expr, RDevice.SVG);

	//		} catch (Exception e) {

	//			throw new StatException(e);

	//		}

	//	}

	/**

	 * The dif ferent types in the lexicon, the type at the index <code>j</code>

	 * of this array have the frequency at index <code>j</code> in the array

	 * returned by {@link #getFreq()}.

	 * 

	 * @return types as an array of <code>String</code>

	 */

	public String[] getForms() {

		if (forms == null) {

			if(ids == null) {

				return new String[0];

			}

			try {

				forms = CorpusManager.getCorpusManager().getCqiClient().id2Str(pProperty.getQualifiedName(), ids);

			} catch (Exception e) {

				// TODO Auto-generated catch block

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

			}

		}

		return forms;

	}

	/**

	 * The dif ferent types in the lexicon, the type at the index <code>j</code>

	 * of this array have the frequency at index <code>j</code> in the array

	 * returned by {@link #getFreq()}.

	 *

	 * @param number the number

	 * @return types as an array of <code>String</code>

	 */

	public String[] getForms(int number) {

		//System.out.println("Lexicon("+this.property+" get forms. number="+number+", ids len="+ids.length);

		if (forms == null) {

			try {

				number = Math.min(number, ids.length);

				if (number <= 0) {

					return new String[0];

				}

				int[] subpositions = new int[number];

				System.arraycopy(ids, 0, subpositions, 0, number);

				return CorpusManager.getCorpusManager().getCqiClient().id2Str(pProperty.getQualifiedName(), subpositions);

			} catch (Exception e) {

				// TODO Auto-generated catch block

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

				return null;

			}

		} else {

			number = Math.min(number, ids.length);

			if (number <= 0) {

				return new String[0];

			}

			String[] subforms = new String[number];

			System.arraycopy(ids, 0, subforms, 0, number);

			return subforms;

		}

	}

	/**

	 * The dif ferent frequencies in the lexicon. See {@link #getForms()}.

	 * 

	 * @return frequencies as an array of <code>int</code>

	 */

	public int[] getFreq() {

		return freqs;

	}

	/**

	 * return the ids of the entries.

	 *

	 * @return types as an array of <code>String</code>

	 */

	public int[] getIds() {

		return ids;

	}

	public String getName() {

		try {

			return this.corpus.getSimpleName() + ": " + this.getSimpleName();	

		}

		catch(Exception e) {

		}

		return ""; //$NON-NLS-1$

	}

	/**

	 * The property this lexicon is build on.

	 * 

	 * @return the property

	 */

	public Property getProperty() {

		return pProperty;

	}

	public String getSimpleName() {

			return this.getProperty().getName();

	}

	/**

	 * Gets the symbol.

	 *

	 * @return the symbol

	 */

	public String getSymbol() {

		return this.symbol;

	}

	/**

	 * Hack frequencies using a map to set forms and frequencies

	 *

	 * @param corpus the corpus

	 * @param pProperty the property

	 * @param map the map

	 * {@link CQPCorpus#getLexicon(Property)} or

	 * {@link Subcorpus#getLexicon(Property)}.

	 */

	public boolean hack(Map<String, Integer> map) {

		if (map.size() != forms.length) {

			return false;

		}

		//super(corpus);

		int size = map.size();

		int[] freqs = new int[size];

		String[] forms = map.keySet().toArray(new String[] {});

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

			freqs[i] = map.get(forms[i]);

		}

		this.freqs = freqs;

		return true;

	}

	/**

	 * Protected on purpose: should be accessed through others initializer.

	 *

	 * @param corpus the corpus

	 * @param property the property

	 * @param freq the freq

	 * @param ids the ids

	 * {@link CQPCorpus#getLexicon(Property)} or

	 * {@link Subcorpus#getLexicon(Property)}.

	 */

	protected void init(TXMResult corpus, Property property, int[] freq, int[] ids) {

		if (freq.length != ids.length) {

			throw new IllegalArgumentException("wrong size freq.length != ids.length "+freq.length+" != "+ids.length);

		}

		this.freqs = freq;

		this.ids = ids;

		this.forms = null;

		this.pProperty = property;

	}

	/**

	 * Number of tokens (sum of all the frequencies) in the corpus.

	 * 

	 * @return the size of the corpus or subcorpus.

	 */

	public int nbrOfToken() {

		if (numberOfTokens <= 0) {

			computeNumberOfTokens();

		}

		return numberOfTokens;

	}

	/**

	 * Number of different types in the frequency list.

	 * 

	 * @return number of types in the corpus or subcorpus.

	 */

	public int nbrOfType() {

		try {

			return freqs.length;

		}

		catch (Exception e) {

			return 0;

		}

	}

	public void setParameters(Property property) {

		this.pProperty = property;

	}

	public boolean setParameters(TXMParameters parameters) {

		try {

			Property p = (Property) parameters.get("properties");

			this.setParameters(p);

		} catch (Exception e) {

			Log.printStackTrace(e);

			return false;

		}

		return true;

	}

	/**

	 * Sets the symbol.

	 *

	 * @param symbol the new symbol

	 */

	public void setSymbol(String symbol) {

		this.symbol = symbol;

	}

	@Override

	public String toString() {

		return this.getName();

	}

	/**

	 * To txt.

	 *

	 * @param outfile the outfile

	 * @param encoding the encoding

	 * @param colseparator the colseparator

	 * @param txtseparator the txtseparator

	 * @return true, if successful

	 */

	@Deprecated

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

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

		// OutputStreamWriter writer;

		try {

			this.writer = new OutputStreamWriter(new FileOutputStream(outfile),

					encoding); 

		} catch (UnsupportedEncodingException e1) {

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

			return false;

		} catch (FileNotFoundException e1) {

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

			return false;

		}

		try {

			writer.write(this.dump(colseparator, txtseparator));

			writer.close();

		} catch (IOException e) {

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

			return false;

		}

		return true;

	}

	/**

	 * Sets the unit property.

	 * @param property the unit property

	 */

	public void setProperty(Property property) {

		this.pProperty = property;

	}

	public static CQPLexicon getLexicon(CQPCorpus corpus, Property property, IProgressMonitor monitor, boolean visible) throws Exception {

		CQPLexicon lexicon = null;

		// recycling parent Lexicon if exists 

		ArrayList<CQPLexicon> partLexicons = (ArrayList<CQPLexicon>) corpus.getObjectCacheForClass(CQPLexicon.class);

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

			if(partLexicons.get(i).getProperty() == property)	{

				lexicon = partLexicons.get(i);

				break;

			}

		}

		// creating new Lexicon

		if(lexicon == null || !lexicon.getProperty().getFullName().equals(property.getFullName()))	{

			lexicon = new CQPLexicon(corpus);

			lexicon.setProperty(property);

		}

		System.out.println("Lexicon="+lexicon+" "+lexicon.hashCode());

		return lexicon;

	}

	/**

	 * Gets a Lexicon from the specified corpus.

	 * If a Lexicon child exists in the Corpus from the specified property, returns it otherwise creates and computes a new Lexicon.

	 * @param corpus

	 * @param property

	 * @return

	 * @throws Exception

	 */

	public static CQPLexicon getLexicon(CQPCorpus corpus, Property property, IProgressMonitor monitor) throws Exception {

		return getLexicon(corpus, property, monitor, true);

	}

//	/**

//	 * Find or build a lexicon given a Corpus (MainCorpus or SubCorpus).

//	 * 

//	 * @param corpus

//	 * @param property

//	 * @return a Lexicon. May return null if the lexicon forms or freqs are null.

//	 * @throws Exception 

//	 */

//	public static Lexicon getLexicon(Corpus corpus, Property property) throws Exception {

//		HashSet<Object> results = corpus.getStoredData(Lexicon.class);

//		for (Object result : results) {

//			Lexicon lex = (Lexicon)result;

//			if (lex.getProperty().equals(property)) {

//				return lex;

//			}

//		}

//

//		Lexicon lex = new Lexicon(corpus);

//		lex.setParameters(property);

//		if (lex.compute(null) && lex.getForms() != null && lex.getFreq() != null) {

//			corpus.storeData(lex);

//			return lex;

//		} else {

//			return null;

//		}

//	}

	public CQPCorpus getParent() {

		return corpus;

	}

}

	/**

	 * Empty the corpus cache

	 */

	@Override

	public void clean() {

		if (cache != null) {

			cache.clear();

		}

	}

	protected static HashMap<Class<?>, ArrayList<?>> cache = new HashMap<Class<?>, ArrayList<?>>();

	private static final int CACHE_MAXIMUM_SIZE = 5;

	/**

	 * retrieve all cached objects for an object 

	 * @param forObject

	 * @param c

	 * @return

	 */

	public static HashMap<Class<?>, ArrayList<?>> getObjectCache() {

		return cache;

	}

	/**

	 * retrieve all cached objects of a certain class for an object 

	 * @param forObject

	 * @param c

	 * @return

	 */

	public static ArrayList<?> getObjectCacheForClass(Class<?> c) {

		HashMap<Class<?>, ArrayList<?>> oCache = getObjectCache();

		if (!oCache.containsKey(c)) {

			oCache.put(c, new ArrayList<Object>());

		}

		return oCache.get(c);

	}

	/**

	 * store an object for a maximum of 5 object cached per object 

	 * @param forObject

	 * @param toCache

	 * @return

	 */

	public static Object cache(Object toCache) {

		if (toCache == null) return null;

		ArrayList<?> ocCache = getObjectCacheForClass(toCache.getClass());

		if (ocCache.size() > CACHE_MAXIMUM_SIZE) {

			ocCache.remove(0); // oldest value

		}

		return toCache;

	}

	/**

	 * remove a cached object

	 * 

	 * @param forObject

	 * @param toCache

	 * @return

	 */

	public static boolean uncache(Object toUnCache) {

		if (toUnCache == null) return false;

		ArrayList<?> ocCache = getObjectCacheForClass(toUnCache.getClass());

		return ocCache.remove(toUnCache);

	}

	/**

	 * remove a cached object

	 * 

	 * @param forObject

	 * @param toCache

	 * @return

	 */

	public static ArrayList<?> uncache(Class classToUnCache) {

		if (classToUnCache == null) return null;

		return cache.remove(classToUnCache);

	}

		super.clean();

		super.clean();

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

		List<CQPLexicon> partsLexicons = new ArrayList<CQPLexicon>();

			partsLexicons.add(CQPLexicon.getLexicon(partition.getParts().get(i), this.property, this.monitor, false));

		CQPLexicon corpusLexicon = CQPLexicon.getLexicon(partition.getParent(), this.property, this.monitor, false);

			CQPLexicon l = partsLexicons.get(i);

			CQPLexicon l1 = CQPLexicon.getLexicon(parentCorpus, property, monitor, false);

			CQPLexicon l2 = CQPLexicon.getLexicon(subcorpus, property, monitor, false);

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

import org.txm.statsengine.r.core.data.VectorImpl;

	/** The nolex. */

	protected static int nolex = 1;

	/** The prefix r. */

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

	 * Convert the Lexicon into a Vector object.

	 * TODO move this code somewhere

	 * @return the vector

	 * @throws StatException the stat exception

	 */

	public static Vector asVector(CQPLexicon lex) throws StatException {

		String symbol = prefixR + (nolex++);

		VectorImpl v = new VectorImpl(lex.getFreq(), symbol);

		v.setRNames(lex.getForms());

		lex.setSymbol(v.getSymbol());

		return v;

	}

	/**

	public LexicalTableImpl(String symbol, CQPLexicon corpusLexicon, CQPLexicon subcorpusLexicon) throws StatException {

		Vector corpusLexiconV = asVector(corpusLexicon);

		Vector subcorpusLexiconV = asVector(subcorpusLexicon);

			treeViewer.setInput(w);

			treeViewer.refresh();