Laboratoire ICAR » Plateforme TXM

package dictionary;

import org.eclipse.ui.plugin.AbstractUIPlugin;

import org.osgi.framework.BundleContext;

/**

 * The activator class controls the plug-in life cycle

 */

public class Activator extends AbstractUIPlugin {

	// The plug-in ID

	public static final String PLUGIN_ID = "Dictionary"; //$NON-NLS-1$

	// The shared instance

	private static Activator plugin;

	/**

	 * The constructor

	 */

	public Activator() {

	}

	/*

	 * (non-Javadoc)

	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext)

	 */

	public void start(BundleContext context) throws Exception {

		super.start(context);

		plugin = this;

	}

	/*

	 * (non-Javadoc)

	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext)

	 */

	public void stop(BundleContext context) throws Exception {

		plugin = null;

		super.stop(context);

	}

	/**

	 * Returns the shared instance

	 *

	 * @return the shared instance

	 */

	public static Activator getDefault() {

		return plugin;

	}

}

package org.txm.dictionary.commands;

import java.io.File;

import org.eclipse.core.commands.ExecutionEvent;

import org.osgi.framework.Version;

import org.txm.PostInstallationStep;

import org.txm.Toolbox;

import org.txm.core.preferences.TBXPreferences;

import org.txm.core.preferences.TXMPreferences;

import org.txm.dictionary.preferences.DictionaryPreferences;

import org.txm.rcp.TxmPreferences;

import org.txm.utils.BundleUtils;

import org.txm.utils.logger.Log;

/**

 * Copy macros from bundle to TXM macro directory

 * 

 * @author mdecorde

 *

 */

public class DoInstallStep  extends PostInstallationStep {

	public static String ID = "org.txm.dictionary.commands.DoInstallStep"; //$NON-NLS-1$

	public static final String VERSION = "org.txm.dictionary.version";

	public void install() {

		Log.info("Dictionary.DoInstallStep.install()");

		String saved = TXMPreferences.getString(DictionaryPreferences.VERSION, DictionaryPreferences.PREFERENCES_NODE);

		Version currentVersion = BundleUtils.getBundleVersion("Dictionary");

		if (saved != null && saved.length() > 0) {

			Version savedVersion = new Version(saved);

			if (currentVersion.compareTo(savedVersion) <= 0) {

				Log.info("No post-installation of Dictionary to do.");

				//System.out.println("No post-installation of Dictionary to do.");

				return; // nothing to do

			}

		}

		System.out.println("Post-installing Dictionary version="+currentVersion);

		File macroDirectory = new File(TXMPreferences.getString(TBXPreferences.USER_TXM_HOME, TBXPreferences.PREFERENCES_NODE), "scripts/macro/org/txm/macro");

		if (!BundleUtils.copyFiles("Dictionary", "src", "org/txm/macro/", "frolex", macroDirectory)) {

			System.out.println("Error while coping Dictionary org/txm/macro/frolex in "+macroDirectory.getAbsolutePath());

			return;

		}

		Log.warning("Dictionary post-installation done.");

		TXMPreferences.put(DictionaryPreferences.PREFERENCES_NODE, DictionaryPreferences.VERSION, currentVersion.toString());

		return;

	}

	public DoInstallStep() {

		name = "Dictionary";

	}

}

package org.txm.dictionary.commands;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.kohsuke.args4j.Option;

import org.txm.dictionary.functions.sql.Dictionary;

import org.txm.dictionary.functions.sql.DictionaryManager;

import org.txm.rcp.swt.widget.parameters.ParametersDialog;

public class DeleteDictionary extends AbstractHandler {

	@Option(name="name", usage="dictionary name 1", widget="String", required=true, def="bfmlex")

	public String name = null;

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		try {

			if (ParametersDialog.open(this)) {

				remove(name);

			}

		} catch (Exception e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

		return null;

	}

	public static void remove(String name) throws Exception {

		DictionaryManager.getInstance().remove(name);

	}

}

package org.txm.dictionary.commands;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.kohsuke.args4j.Option;

import org.txm.dictionary.functions.sql.DictionaryManager;

import org.txm.rcp.swt.widget.parameters.ParametersDialog;

public class QueryDictionary extends AbstractHandler {

	@Option(name="query", usage="SQL query, can contains $NAME which will be replace with the dictionary SQL name", widget="String", required=true, def="SELECT * FROM $NAME")

	public String query;

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		try {

			if (ParametersDialog.open(this)) {

					return query(query);

			}

			return -1;

		} catch (Exception e) {

			e.printStackTrace();

		}

		return null;

	}

	public static int query(String query) throws Exception {

		int n = DictionaryManager.getInstance().queryAndPrint(query);

		System.out.println("Result size="+n);

		return n;

	}

}

package org.txm.dictionary.commands;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.kohsuke.args4j.Option;

import org.txm.dictionary.functions.sql.Dictionary;

import org.txm.dictionary.functions.sql.DictionaryManager;

import org.txm.rcp.swt.widget.parameters.ParametersDialog;

public class AddColumnDictionary extends AbstractHandler {

	@Option(name="name", usage="dictionary name", widget="String", required=true, def="conv.tsv")

	public String name = null;

	@Option(name="type", usage="type", widget="String", required=true, def="type")

	public String type = null;

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		try {

			if (ParametersDialog.open(this)) {

				if (DictionaryManager.getInstance().hasDictionary(name)) {

					Dictionary d = DictionaryManager.getInstance().getDictionary(name);

					add(d, type);

				}

			}

			return null;

		} catch (Exception e) {

			e.printStackTrace();

		}

		return null;

	}

	public static Dictionary add(Dictionary d, String type) throws Exception {

		if (d.getTypes().contains(type)) {

			System.out.println("Column already exists.");

			return d;

		}

		d.addType(type);

		System.out.println("Type="+type+" added to "+d.getName());

		return null;

	}

}

package org.txm.dictionary.commands;

import java.util.Arrays;

import java.util.LinkedHashMap;

import java.util.List;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.kohsuke.args4j.Option;

import org.txm.dictionary.functions.sql.Dictionary;

import org.txm.dictionary.functions.sql.DictionaryManager;

import org.txm.rcp.swt.widget.parameters.ParametersDialog;

public class MergeDictionaries extends AbstractHandler {

	@Option(name="name", usage="dictionary name 1", widget="String", required=true, def="bfmlex")

	public String name = null;

	@Option(name="name2", usage="dictionary name 2", widget="String", required=true, def="bfmgoldlex")

	public String name2 = null;

	@Option(name="cols", usage="columns", widget="String", required=true, def="word,pos")

	public String cols = null;

	@Option(name="aggregatescols", usage="the other columns", widget="String", required=true, def="F")

	public String aggregatescols = null;

	@Option(name="aggregates", usage="the agregates instruction for each other column.", widget="String", required=true, def="MAX")

	public String aggregates = null;

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		try {

			if (ParametersDialog.open(this)) {

				if (DictionaryManager.getInstance().hasDictionary(name) && DictionaryManager.getInstance().hasDictionary(name2)) {

					Dictionary d = DictionaryManager.getInstance().getDictionary(name);

					Dictionary d2 = DictionaryManager.getInstance().getDictionary(name2);

					List<String> colsList = Arrays.asList(cols.split(","));

					List<String> aggregatescolsList = Arrays.asList(aggregatescols.split(","));

					List<String> aggregateList = Arrays.asList(aggregates.split(","));

					return merge(d, d2, colsList, aggregatescolsList, aggregateList);

				} else {

					System.out.println("Error: a dictionary is missing: "+name+" or "+name2);

				}

			}

			return null;

		} catch (Exception e) {

			e.printStackTrace();

		}

		return null;

	}

	public static Dictionary merge(Dictionary d, Dictionary d2, List<String> cols, List<String> aggregatescols, List<String> aggregates) throws Exception {

		if (aggregatescols.size() != aggregates.size()) {

			System.out.println("other columns and aggregates size differs: others="+aggregatescols.size()+" aggregates="+aggregates.size());

			return null;

		}

		LinkedHashMap<String, String> agregateInstructions = new LinkedHashMap<String, String>();

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

			agregateInstructions.put(aggregatescols.get(i), aggregates.get(i));

		}

		int n = d2.mergeWith(d, cols, agregateInstructions);

		if (n == 0) System.out.println("No entry added");

		else if (n == 1) System.out.println("One entry added.");

		else  System.out.println(""+n+" entries added");

		return d2;

	}

}

package org.txm.dictionary.commands;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.PrintWriter;

import java.io.UnsupportedEncodingException;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedHashMap;

import java.util.LinkedHashSet;

import java.util.List;

import org.apache.commons.lang.StringUtils;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.kohsuke.args4j.Option;

import org.txm.dictionary.functions.sql.Dictionary;

import org.txm.dictionary.functions.sql.DictionaryManager;

import org.txm.rcp.swt.widget.parameters.ParametersDialog;

import org.txm.rcp.utils.JobHandler;

import org.txm.utils.io.IOUtils;

import org.txm.utils.logger.Log;

public class ExportToTreeTagger extends AbstractHandler {

	@Option(name="name", usage="dictionary name", widget="String", required=true, def="frolex")

	public String name = null;

	@Option(name="pos", usage="pos property", widget="String", required=true, def="msd_cattex_conv")

	public String pos = null;

	@Option(name="lemma", usage="lemma property", widget="String", required=true, def="lemma")

	public String lemma = null;

	@Option(name="ignoredPosValues", usage="types", widget="String", required=true, def="<nopos>,,")

	public String ignoredPosValues = null;

	@Option(name="tsvfile", usage="tsvfile", widget="File", required=true, def="lexicon.txt")

	public File tsvfile = null;

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		try {

			if (ParametersDialog.open(this)) {

				JobHandler job = new JobHandler("TreeTagger lexicon export "+name) {

					@Override

					protected IStatus run(IProgressMonitor monitor) {

						this.runInit(monitor);

						try {

							if (DictionaryManager.getInstance().hasDictionary(name)) {

								Dictionary d = DictionaryManager.getInstance().getDictionary(name);

								HashSet<String> ignoredPosValuesSet = new HashSet<String>(split(ignoredPosValues));

								export(d, pos, lemma, ignoredPosValuesSet, tsvfile);

							}

						} catch (Exception e) {

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

							Log.printStackTrace(e);

						}

						return Status.OK_STATUS;

					}

				};

				job.schedule();

			}

			return null;

		} catch (Exception e) {

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

			Log.printStackTrace(e);

		}

		return null;

	}

	public static ArrayList<String> split(String s) {

		ArrayList<String> result = new ArrayList<String>();

		int idx = s.indexOf(",");

		if (idx < 0) return result;

		while (idx >= 0) {

			String s1 = s.substring(0, idx);

			result.add(s1);

			s = s.substring(idx+1);

			idx = s.indexOf(",");

		}

		result.add(s);

		return result;

	}

	private static StringBuilder b = new StringBuilder();

	public static String join(Collection<String> values, String sep) {

		b.setLength(0);

		for (String s: values) b.append(s+"\t");

		return b.substring(0, b.length()-1);

	}

	public static boolean export(Dictionary d, String pos, String lemma, HashSet<String> ignoredPosValues, File tsvfile) throws UnsupportedEncodingException, FileNotFoundException, SQLException {

		System.out.println("Merging lines of "+d+" in "+tsvfile);

		System.out.println(" pos property="+pos);

		System.out.println(" lemma property="+lemma);

		System.out.println(" ignoredvalues="+ignoredPosValues);

		List<String> columns = d.getTypes();

		if (!columns.contains("form")) {

			System.out.println("Type not found in dictionary: "+"form");

			return false;

		}

		if (!columns.contains(pos)) {

			System.out.println(pos+" type not found in dictionary: "+columns);

			return false;

		}

		if (!columns.contains(lemma)) {

			System.out.println(lemma+" type not found in dictionary: "+columns);

			return false;

		}

		String TAB = "\t";

		PrintWriter writer = IOUtils.getWriter(tsvfile, "UTF-8");

		ResultSet result = d.getSortedLines("form");

		String currentForm = null;

		HashMap<String, HashSet<String>> posFound = new HashMap<String, HashSet<String>>();

		while (result.next()) { // for each form entry

			String form = result.getString("form");

			String ignoreValue = result.getString(pos);

			if (ignoredPosValues.size() > 0 && ignoredPosValues.contains(ignoreValue)) { continue; } // ignore "<nopos>" pos values entries

			if (!form.equals(currentForm)) { // append to the current merged line

				if (currentForm != null && posFound.size() > 0) { // write the line if the word has pos

					writer.print(currentForm);

					for (String posValue : posFound.keySet()) { // for each pos, sort the lemmas

						ArrayList<String> lemmaValues = new ArrayList<String>();

						lemmaValues.addAll(posFound.get(posValue));

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

							@Override

							public int compare(String o1, String o2) {

								if (o2.contains("no_lemma")) return -1;

								else if (o2.contains("nolem")) {return -1;}

								else if (o1.contains("no_lemma")) return 1;

								else if (o1.contains("nolem")) {return 1;}

								return 0;

							}

						});

						if (lemmaValues.size() > 1) lemmaValues.remove("<no_lemma>"); // remove <no_lemma> if there are others lemma values

						writer.print("\t"+posValue+" "+StringUtils.join(lemmaValues, "|"));

					}

					writer.println(""); // end of line

				} else {

					System.out.println("Form '"+currentForm+"' has no pos-lemme couple.");

				}

				posFound.clear();

				currentForm = form;

			}

			String firstValue = result.getString(pos);

			if (!posFound.containsKey(firstValue)) posFound.put(firstValue, new HashSet<String>()); // avoid repeating the first type value 

			String value = result.getString(lemma).trim();

			if (value == null) {

				System.out.println("Error: null value for type="+lemma);

				writer.close();

				return false;

			} 

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

				value = "<no_lemma>"; 

			}

			posFound.get(firstValue).add(value); // add the new lemma for this pos value

		}

		writer.close();

		result.getStatement().close(); // :-)

		System.out.println("Result saved in "+tsvfile.getAbsolutePath());

		return true;

	}

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

		File frolexTSV = new File("/home/mdecorde/TXM/results/lexique BFM/result/frolex.tsv");

		File frolexTT = new File("/home/mdecorde/TXM/results/lexique BFM/result/frolex-tt.tsv");

		DictionaryManager.getInstance().remove("bfmlex");

		Dictionary frolex = DictionaryManager.getInstance().getDictionary("frolex");

		frolex.loadFromTSVFile(frolexTSV);

		ArrayList<String> types = new ArrayList<String>();

		types.add("msd_cattex_conv");

		types.add("lemma");

		String ignoredTestType = "msd_cattex_conv";

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

		ignoredvalues.add("<nopos>");

		ignoredvalues.add("");

		export(frolex,"msd_cattex_conv", "lemma", ignoredvalues, frolexTT);

	}

}

package org.txm.dictionary.commands;

import java.io.File;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.kohsuke.args4j.Option;

import org.txm.dictionary.functions.sql.Dictionary;

import org.txm.dictionary.functions.sql.DictionaryManager;

import org.txm.rcp.swt.widget.parameters.ParametersDialog;

import org.txm.rcp.utils.JobHandler;

import org.txm.utils.logger.Log;

public class ImportDictionary extends AbstractHandler {

	@Option(name="name", usage="dictionary name", widget="String", required=true, def="name")

	public String name = null;

	@Option(name="tsvfile", usage="tsvfile", widget="File", required=true, def="lexique.tsv")

	public File tsvfile = null;

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		try {

			if (ParametersDialog.open(this)) {

				JobHandler job = new JobHandler("UniqSort "+name) {

					@Override

					protected IStatus run(IProgressMonitor monitor) {

						this.runInit(monitor);

						try {

							importFromTSVFile(tsvfile, name);

						} catch (Exception e) {

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

							Log.printStackTrace(e);

						}

						return Status.OK_STATUS;

					}

				};

				job.schedule();

			}

			return null;

		} catch (Exception e) {

			e.printStackTrace();

		}

		return null;

	}

	public static Dictionary importFromTSVFile(File tsvFile, String name) throws Exception {

		DictionaryManager dm = DictionaryManager.getInstance();

		Dictionary d = dm.getDictionary(name);

		if (d == null) {

			System.out.println("Error: could not create or get dictionary with name="+name);

		}

		if (d.loadFromTSVFile(tsvFile)) {

			return d;

		}

		return null;

	}

}

package org.txm.dictionary.commands;

import java.io.File;

import java.io.IOException;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.swt.SWT;

import org.eclipse.swt.widgets.FileDialog;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.ui.handlers.HandlerUtil;

import org.kohsuke.args4j.Option;

import org.txm.dictionary.functions.sql.Dictionary;

import org.txm.dictionary.functions.sql.DictionaryManager;

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

import org.txm.rcp.swt.widget.parameters.ParametersDialog;

import org.txm.rcp.utils.JobHandler;

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

import org.txm.utils.logger.Log;

public class CreateDictionaryFromIndex  extends AbstractHandler {

	@Option(name="name", usage="dictionary name", widget="String", required=true, def="conv.tsv")

	public String name = null;

	@Option(name="tsvFile", usage="tsvFile", widget="File", required=true, def="conv.tsv")

	public File tsvFile = null;

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		IStructuredSelection selection = (IStructuredSelection) HandlerUtil.getCurrentSelection(event);

		Object o = selection.getFirstElement();

		if (!(o instanceof Index)) return null;

		final Index index = (Index)o;

		if (ParametersDialog.open(this)) {

			JobHandler job = new JobHandler("UniqSort "+name) {

				@Override

				protected IStatus run(IProgressMonitor monitor) {

					this.runInit(monitor);

					try {

						fromIndex(index, tsvFile, name);

					} catch (Exception e) {

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

						Log.printStackTrace(e);

					}

					return Status.OK_STATUS;

				}

			};

			job.schedule();

		}

		return null;

	}

	public static Dictionary fromIndex(Index index, File tsvFile, String name) throws Exception {

		index.toTSVDictionnary(tsvFile, "\t", "UTF-8");

		return ImportDictionary.importFromTSVFile(tsvFile, name);

	}

}

package org.txm.dictionary.commands;

import java.io.File;

import java.io.Serializable;

import java.sql.SQLException;

import java.util.LinkedHashMap;

import java.util.regex.Pattern;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.kohsuke.args4j.Option;

import org.txm.dictionary.functions.sql.Dictionary;

import org.txm.dictionary.functions.sql.DictionaryManager;

import org.txm.rcp.swt.widget.parameters.ParametersDialog;

import org.txm.rcp.utils.JobHandler;

import org.txm.utils.logger.Log;

public class RecodeColumnDictionary extends AbstractHandler {

	@Option(name="name", usage="dictionary name", widget="String", required=true, def="conv.tsv")

	public String name = null;

	@Option(name="conversionFile", usage="conversionFile", widget="File", required=true, def="conv.tsv")

	public File conversionFile = null;

	@Option(name="type", usage="type", widget="String", required=true, def="type")

	public String type = null;

	@Option(name="newType", usage="newType", widget="String", required=true, def="newType")

	public String newType = null;

	@Option(name="mode", usage="'supprimer' to delete entries without rule, 'abandon' to stop if errors and 'copier' to copy value if no rule", widget="String", required=true, def="abandon")

	public String mode = "abandon";

	@Option(name="oneMatch", usage="stop at first match", widget="String", required=true, def="true")

	public boolean oneMatch = true;

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		if (ParametersDialog.open(this)) {

			try {

				if (DictionaryManager.getInstance().hasDictionary(name)) {

					JobHandler job = new JobHandler("UniqSort "+name) {

						@Override

						protected IStatus run(IProgressMonitor monitor) {

							this.runInit(monitor);

							try {

								Dictionary d = DictionaryManager.getInstance().getDictionary(name);

								recode(d, conversionFile, type, newType, mode, oneMatch);

							} catch (Exception e) {

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

								Log.printStackTrace(e);

								return Status.CANCEL_STATUS;

							}

							return Status.OK_STATUS;

						}

					};

					job.schedule();

				}

			} catch (SQLException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			} catch (Exception e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

		}

		return null;

	}

	public static Dictionary recode(Dictionary d, File conversionTSVFile, String type, String newType, String mode, boolean oneMatch) throws Exception {

		LinkedHashMap<Pattern, Serializable[]> conversionRules = Dictionary.getConversionRulesFromFile(conversionTSVFile);

		if (conversionRules.size() > 0) {

			d.recodeEntryProperties(type, newType, conversionRules, mode, oneMatch);

		}

		return null;

	}

}

package org.txm.dictionary.commands;

import java.io.File;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.kohsuke.args4j.Option;

import org.txm.dictionary.functions.sql.Dictionary;

import org.txm.dictionary.functions.sql.DictionaryManager;

import org.txm.rcp.swt.widget.parameters.ParametersDialog;

import org.txm.rcp.utils.JobHandler;

import org.txm.utils.logger.Log;

public class ExportDictionary extends AbstractHandler {

	@Option(name="name", usage="the dictionary name", widget="String", required=true, def="lex")

	public String name = null;

	@Option(name="tsvFile", usage="tsvFile", widget="FileSave", required=true, def="dict.tsv")

	public File tsvFile = null;

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		if (ParametersDialog.open(this)) {

			try {

				if (!DictionaryManager.getInstance().hasDictionary(name)) {

					System.out.println("Error: no dictionary named "+name);

					return null;

				}

			} catch (Exception e1) {

				// TODO Auto-generated catch block

				e1.printStackTrace();

				return null;

			}

			JobHandler job = new JobHandler("UniqSort "+name) {

				@Override

				protected IStatus run(IProgressMonitor monitor) {

					this.runInit(monitor);

					try {

						Dictionary d = DictionaryManager.getInstance().getDictionary(name);

						exportToTSVFile(d, tsvFile);

					} catch (Exception e) {

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

						Log.printStackTrace(e);

					}

					return Status.OK_STATUS;

				}

			};

			job.schedule();

		}

		return null;

	}

	public static Dictionary exportToTSVFile(Dictionary d, File tsvFile) throws Exception {

		if (d.print(tsvFile)) {

			return d;

		}

		return null;

	}

}

package org.txm.dictionary.commands;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.kohsuke.args4j.Option;

import org.txm.dictionary.functions.sql.Dictionary;

import org.txm.dictionary.functions.sql.DictionaryManager;

import org.txm.rcp.swt.widget.parameters.ParametersDialog;

public class CopyDictionaries extends AbstractHandler {

	@Option(name="orig", usage="orig dictionary name", widget="String", required=true, def="orig")

	public String orig = null;

	@Option(name="copy", usage="copy dictionary name", widget="String", required=true, def="copy")

	public String copy = null;

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		try {

			if (ParametersDialog.open(this)) {

				if (DictionaryManager.getInstance().hasDictionary(orig)) {

					Dictionary d = DictionaryManager.getInstance().getDictionary(orig);

					return copy(d, copy);

				}

			}

			return null;

		} catch (Exception e) {

			e.printStackTrace();

		}

		return null;

	}

	public static Dictionary copy(Dictionary d, String d2) throws Exception {

		int n = d.makeCopy(d2);

		if (n == 0) System.out.println("No entry copied");

		else if (n == 1) System.out.println("One entry copied.");

		else  System.out.println(""+n+" entries copied");

		return DictionaryManager.getInstance().getDictionary(d2);

	}

}

package org.txm.dictionary.commands;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.txm.dictionary.functions.sql.Dictionary;

import org.txm.dictionary.functions.sql.DictionaryManager;

public class ListDictionaries extends AbstractHandler {

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		try {

			list();

		} catch (Exception e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

		return null;

	}

	public static Dictionary list() throws Exception {

		System.out.println("Tables: "+DictionaryManager.getInstance().getHSQLFunctions().getTables());

		System.out.println("Dictionaries: "+DictionaryManager.getInstance().getDictionaries());

		return null;

	}

}

package org.txm.dictionary.commands;

import java.io.File;

import java.sql.SQLException;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.kohsuke.args4j.Option;

import org.txm.dictionary.functions.sql.Dictionary;

import org.txm.dictionary.functions.sql.DictionaryManager;

import org.txm.rcp.swt.widget.parameters.ParametersDialog;

import org.txm.rcp.utils.JobHandler;

import org.txm.utils.logger.Log;

public class UniqSortDictionary extends AbstractHandler {

	@Option(name="name", usage="the dictionary name", widget="String", required=true, def="lex")

	public String name = null;

	@Option(name="tsvFile", usage="conversionFile", widget="FileSave", required=true, def="conv.tsv")

	public File tsvFile = null;

	@Option(name="col", usage="the clumn to uniqsort", widget="String", required=true, def="form")

	public String col = null;

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		try {

			if (ParametersDialog.open(this)) {

				if (DictionaryManager.getInstance().hasDictionary(name)) {

					JobHandler job = new JobHandler("UniqSort "+name) {

						@Override

						protected IStatus run(IProgressMonitor monitor) {

							this.runInit(monitor);

							try {

								if (!DictionaryManager.getInstance().hasDictionary(name)) {

									System.out.println("Error: the dictionary does exists: "+name);

									return Status.CANCEL_STATUS;

								}

								Dictionary d = DictionaryManager.getInstance().getDictionary(name);

								if (!d.getTypes().contains(col)) {

									System.out.println("Error: the dictionary does nto contains the given column: "+col);

									return Status.CANCEL_STATUS;

								}

								if (uniqsort(d, tsvFile, col) == null) {

									System.out.println("Error: the dictionary uniqsort failed.");

									return Status.CANCEL_STATUS;

								}

								return Status.OK_STATUS;

							} catch (Exception e) {

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

								Log.printStackTrace(e);

								return Status.CANCEL_STATUS;

							}

						}

					};

					job.schedule();

				}

			}

		} catch (Exception e) {

			e.printStackTrace();

		}

		return null;

	}

	public static Dictionary uniqsort(Dictionary d, File tsvFile, String col) throws Exception {

		if (d.uniqsort(tsvFile, col)) {

			return d;

		}

		return null;

	}

}

package org.txm.dictionary.commands;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.kohsuke.args4j.Option;

import org.txm.dictionary.functions.sql.Dictionary;

import org.txm.dictionary.functions.sql.DictionaryManager;

import org.txm.rcp.swt.widget.parameters.ParametersDialog;

public class RenameColumnDictionary extends AbstractHandler {

	@Option(name="name", usage="dictionary name", widget="String", required=true, def="conv.tsv")

	public String name = null;

	@Option(name="oldtype", usage="oldtype", widget="String", required=true, def="old")

	public String oldtype = null;

	@Option(name="newtype", usage="the new name", widget="String", required=true, def="new")

	public String newtype = null;

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		try {

			if (ParametersDialog.open(this)) {

				if (DictionaryManager.getInstance().hasDictionary(name)) {

					Dictionary d = DictionaryManager.getInstance().getDictionary(name);

					rename(d, oldtype, newtype);

				}

			}

			return null;

		} catch (Exception e) {

			e.printStackTrace();

		}

		return null;

	}

	public static Dictionary rename(Dictionary d, String oldtype, String newtype) throws Exception {

		if (d.getTypes().contains(newtype)) {

			System.out.println("Column already exists: "+d.getTypes());

			return d;

		}

		if (d.getTypes().contains(oldtype)) {

			System.out.println("The old column does not exists: "+d.getTypes());

			return d;

		}

		d.renameType(oldtype, newtype);

		System.out.println("Type renamed="+d.getTypes());

		return null;

	}

}

package org.txm.dictionary.commands;

import java.io.File;

import java.io.Serializable;

import java.util.HashMap;

import java.util.regex.Pattern;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.kohsuke.args4j.Option;

import org.txm.dictionary.functions.sql.Dictionary;

import org.txm.dictionary.functions.sql.DictionaryManager;

import org.txm.rcp.swt.widget.parameters.ParametersDialog;

public class RemoveEntriesDictionary extends AbstractHandler {

	@Option(name="name", usage="dictionary name", widget="String", required=true, def="conv.tsv")

	public String name = null;

	@Option(name="type", usage="type", widget="String", required=true, def="type")

	public String type = null;

	@Option(name="pattern", usage="newType", widget="String", required=true, def="reg exp pattern")

	public String pattern = null;

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		try {

			if (ParametersDialog.open(this)) {

				if (DictionaryManager.getInstance().hasDictionary(name)) {

					Dictionary d = DictionaryManager.getInstance().getDictionary(name);

					//Pattern p = Pattern.compile(pattern);

					removeEntries(d, type, pattern);

				} else {

					System.out.println("No dictionary named '"+name+"'.");

				}

			}

			return null;

		} catch (Exception e) {

			e.printStackTrace();

		}

		return null;

	}

	public static Dictionary removeEntries(Dictionary d, String type, String pattern) throws Exception {

		int n = d.removeEntries(type, pattern);

		if (n == 0) System.out.println("No entry removed");

		else if (n == 1) System.out.println("One entry removed.");

		else  System.out.println(""+n+" entries removed");

		return null;

	}

}

package org.txm.dictionary.commands;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.kohsuke.args4j.Option;

import org.txm.dictionary.functions.sql.Dictionary;

import org.txm.dictionary.functions.sql.DictionaryManager;

import org.txm.dictionary.functions.sql.HSQLFunctions;

import org.txm.rcp.swt.widget.parameters.ParametersDialog;

public class InterDictionaries extends AbstractHandler {

	@Option(name="first", usage="first dictionary name", widget="String", required=true, def="afrlex")

	public String first = null;

	@Option(name="second", usage="second dictionary name", widget="String", required=true, def="frolex")

	public String second = null;

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		try {

			if (ParametersDialog.open(this)) {

				if (DictionaryManager.getInstance().hasDictionary(first)) {

					System.out.println("No dictionary named: "+first);

					return null;

				}

				if (DictionaryManager.getInstance().hasDictionary(second)) {

					System.out.println("No dictionary named: "+second);

					return null;

				}

				if (DictionaryManager.getInstance().hasDictionary(first)) {

					Dictionary firstDict = DictionaryManager.getInstance().getDictionary(first);

					Dictionary secondDict = DictionaryManager.getInstance().getDictionary(second);

					return inter(firstDict, secondDict);

				}

			}

			return null;

		} catch (Exception e) {

			e.printStackTrace();

		}

		return null;

	}

	public static Object inter(Dictionary firstDict, Dictionary secondDict) throws Exception {

		HSQLFunctions functions = DictionaryManager.getInstance().getHSQLFunctions();

		functions.printQuery("SELECT * from \""+firstDict.getName()+"\" WHERE form NOT IN (SELECT \"form\" FROM \""+secondDict+"\")");

		return null;

	}

}

package org.txm.dictionary.commands;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.kohsuke.args4j.Option;

import org.txm.dictionary.functions.sql.Dictionary;

import org.txm.dictionary.functions.sql.DictionaryManager;

import org.txm.rcp.swt.widget.parameters.ParametersDialog;

public class PrintDictionary extends AbstractHandler {

	@Option(name="name", usage="dictionary name", widget="String", required=true, def="conv.tsv")

	public String name = null;

	@Option(name="n", usage="number of line to show", widget="Integer", required=true, def="5")

	public int n;

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		try {

			if (ParametersDialog.open(this)) {

				if (DictionaryManager.getInstance().hasDictionary(name)) {

					Dictionary d = DictionaryManager.getInstance().getDictionary(name);

					return print(d, n);

				} else {

					System.out.println("No dictionary named="+name);

				}

			}

			return null;

		} catch (Exception e) {

			e.printStackTrace();

		}

		return null;

	}

	public static Dictionary print(Dictionary d, int n) throws Exception {

		d.print(n);

		return d;

	}

}

package org.txm.dictionary.commands;

import java.util.HashMap;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.kohsuke.args4j.Option;

import org.txm.dictionary.functions.sql.Dictionary;

import org.txm.dictionary.functions.sql.DictionaryManager;

import org.txm.rcp.swt.widget.parameters.ParametersDialog;

public class GrepDictionary extends AbstractHandler {

	@Option(name="name", usage="dictionary name", widget="String", required=true, def="lex")

	public String name = null;

	@Option(name="col", usage="column", widget="String", required=true, def="column")

	public String col;

	@Option(name="pattern", usage="pattern", widget="String", required=true, def=".+")

	public String pattern;

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		try {

			if (ParametersDialog.open(this)) {

				if (DictionaryManager.getInstance().hasDictionary(name)) {

					Dictionary d = DictionaryManager.getInstance().getDictionary(name);

					return grep(d, col, pattern);

				} else {

					System.out.println("No dictionary named '"+name+"'");

					return -1;

				}

			}

			return -1;

		} catch (Exception e) {

			e.printStackTrace();

		}

		return null;

	}

	public static int grep(Dictionary d, String col, String pattern) throws Exception {

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

		hash.put(col, pattern);

		return grep(d, hash);

	}

	public static int grep(Dictionary d, HashMap<String, String> hash) throws Exception {

		return d.grep(hash);

	}

}

package org.txm.dictionary.preferences;

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

import org.osgi.framework.FrameworkUtil;

import org.osgi.service.prefs.Preferences;

import org.txm.core.preferences.TXMPreferences;

public class DictionaryPreferences extends TXMPreferences {

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

	public static final String VERSION = "dictionary.version"; //$NON-NLS-1$

	@Override

	public void initializeDefaultPreferences() {

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

		preferences.put(VERSION, "");

	}

}

package org.txm.dictionary.functions.jpa;

import java.io.Serializable;

import javax.persistence.Entity;

import javax.persistence.Id;

import org.txm.dictionary.functions.jpa.EntryId;

import org.txm.dictionary.functions.jpa.EntryProperty;

import org.txm.dictionary.functions.jpa.EntryPropertyType;

@Entity

public class EntryPropertyType implements Serializable {

	private static final long serialVersionUID = 7511725970194453783L;

	@Id

	String id;

	public EntryPropertyType() { }

	public EntryPropertyType(String type) {

		this.id = type;

	}

	public String toString(){ return id;}

	public static void main(String[] args) {

		//EntryType form = new EntryType("form");

		EntryPropertyType F = new EntryPropertyType("F");

		EntryPropertyType msd = new EntryPropertyType("msd");

		EntryPropertyType lemma = new EntryPropertyType("lemma");

		EntryId je = new EntryId();

		EntryId tu = new EntryId();

		//EntryProperty form_je = new EntryProperty(je.id, form.id, "je");

		EntryProperty F_je = new EntryProperty(je.id, F.id, 120);

		EntryProperty msd_je = new EntryProperty(je.id, msd.id, "S");

//		EntryProperty lemma_je = new EntryProperty(je.id, lemma.id, "je");

		//EntryProperty form_tu = new EntryProperty(tu.id, form.id, "tu");

		EntryProperty F_tu = new EntryProperty(tu.id, F.id, 50);

		EntryProperty msd_tu = new EntryProperty(tu.id, msd.id, "S");

		EntryProperty lemma_tu = new EntryProperty(tu.id, lemma.id, "tu");

	}

}

package org.txm.dictionary.functions.jpa;

import java.io.File;

import java.util.HashMap;

import org.txm.Toolbox;

import org.txm.core.preferences.TBXPreferences;

import org.txm.core.preferences.TXMPreferences;

import org.txm.dictionary.functions.jpa.Dictionary;

import org.txm.utils.logger.Log;

/**

 * Creates Dictionaries

 * 

 * @author mdecorde