Laboratoire ICAR » Plateforme TXM

import org.eclipse.core.runtime.IProgressMonitor;

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

import org.osgi.service.prefs.BackingStoreException;

import org.osgi.service.prefs.Preferences;

import org.txm.annotation.core.AnnotationEngine;

					kr.getJPAManager().close();

			}

			catch (Exception e) {

				Log.printStackTrace(e);

				success = false;

			}

					am.closeAll();

			}

			catch (Exception e) {

				Log.printStackTrace(e);

				success = false;

			}

import javax.persistence.TypedQuery;

import javax.persistence.spi.PersistenceUnitInfo;

import org.eclipse.persistence.config.PersistenceUnitProperties;

import org.eclipse.persistence.internal.jpa.deployment.JPAInitializer;

import org.eclipse.persistence.internal.jpa.deployment.SEPersistenceUnitInfo;

		emf = pp.createEntityManagerFactory(DatabasePersistenceManager.PERSISTENCE_UNIT_NAME, properties);

		if (emf == null) {

			return null;

		}

		EntityManager entityManager = (EntityManager) emf.createEntityManager();

		this.accessProperties = accessProperties;

		String sVersion = accessProperties.get("version");

			this.version = Integer.parseInt(sVersion);

		this.url = accessProperties.get(TYPE_URL);

		this.values_base_url = accessProperties.get(TYPE_RESURL);

		this.types_base_url = accessProperties.get(TYPE_TYPEURL);

				buildTypes();

			}

			else {

				for (AnnotationType annotType : annotTypes) {

				}

			}

			buildTypes();

		}

import javax.persistence.EntityManager;

import org.txm.annotation.kr.core.DatabasePersistenceManager;

import org.txm.sql.SQLConnection;

import org.txm.utils.logger.Log;

					password);

		}

		catch (Exception e) {

			return null;

		}

				em.persist(value);

				// System.out.println("Value : "+annotationValue+" ("+publicid+"/"+name+") is going to be persisted !"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$

				if (i > 1) {

				}

				i++;

			}

import javax.persistence.EntityManager;

import org.apache.commons.io.FileUtils;

import org.osgi.service.prefs.BackingStoreException;

import org.osgi.service.prefs.Preferences;

import org.txm.Toolbox;

			kr.buildTypesAndValues();

		}

		else {

		}

		return kr;

					repositories.put(name, kr);

				}

				catch (Exception e) {

					Log.printStackTrace(e);

				}

			}

						repositories.put(name, kr);

					}

					else {

						return null;

					}

				}

				catch (Exception e) {

					Log.printStackTrace(e);

				}

			}

			}

			else {

				// replace the KR

				KnowledgeRepository krNew = createKnowledgeRepository(name, corpusprefkrconf);

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

					krNew.saveConfiguration(krconf);

				}

				catch (Exception e) {

					Log.printStackTrace(e);

					return kr;

				}

					repositories.put(name, krNew);

					kr = krNew;

				}

			}

		}

		else {

				kr = krNew;

			}

			else {

				return null;

			}

				krNew.saveConfiguration(krconf);

			}

			catch (Exception e) {

				Log.printStackTrace(e);

				return kr;

			}

		}

		return kr;

				FileUtils.writeStringToFile(newHtmlFile, htmlString);

			}

			catch (Exception e) {

				Log.printStackTrace(e);

			}

		}

		else {

		}

		return newHtmlFile.getAbsolutePath();

		}

		try {

			for (String type : fieldsTypesProperties.keySet()) {

				File f = new File(currentDirectory, type);

				BufferedReader reader = new BufferedReader(new FileReader(f));

				String line = reader.readLine();

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

				while (line != null) {

					if (line.length() > 0) {

						String split[] = line.split("\t", 2);

						TypedValue val = null;

						if (split.length == 2) {

		List<Annotation> annots = tempManager.getAnnotations();

		if (annots.isEmpty()) {

			dirty = false;

			return true;

		}

			tempManager.getEntityManager().getTransaction().begin();

			for (Annotation a : temporaryAnnotations) {

				if (job != null && job.isCanceled()) {

					return false;

				}

				tempManager.deleteAnnotation(type, a.getStart(), a.getEnd());

			tempManager.getEntityManager().getTransaction().begin();

			for (Annotation a : cqpAnnotations) {

				if (job != null && job.isCanceled()) {

					return false;

				}

				String value = cqpManager.getCQPAnnotationValue(a.getStart(), a.getEnd(), type);

				}

				if (job != null && job.isCanceled()) {

					return false;

				}

			tempManager.getEntityManager().getTransaction().commit();

		}

		catch (Exception e) {

			return false;

		}

		return true;

			// System.out.println("Temporary annotations: "+temporaryAnnotations);

			// System.out.println("CQP annotations: "+cqpAnnotations);

			if (cqpAnnotations.size() != matches.size() || temporaryAnnotations.size() != matches.size()) {

				return new ArrayList<>(matches.size());

			}

			// merge the 2 results

			tempManager.close();

		}

		catch (Exception e) {

		}

	}

			}

			if (job != null && job.isCanceled()) { // check if user canceled the job

				return null;

			}

			}

			catch (Throwable e) {

				Log.printStackTrace(e);

				if (tempManager.getEntityManager().getTransaction().isActive()) {

					tempManager.getEntityManager().getTransaction().rollback(); // reset state

				}

import javax.xml.stream.XMLStreamException;

import org.apache.commons.lang.StringUtils;

import org.txm.Toolbox;

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

import org.txm.utils.ConsoleProgressBar;

import org.txm.utils.io.IOUtils;

public class CorpusRuledConvertion {

			line = reader.readLine();

		}

	}

	public CorpusRuledConvertion(LinkedHashMap<Pattern, String> rules,

		File binaryCorpusDirectory = corpus.getProjectDirectory();

		File txmDirectory = new File(binaryCorpusDirectory, "txm");

		if (!txmDirectory.exists()) {

			return false;

		}

		File txmCorpusDirectory = new File(txmDirectory, corpus.getID());

		if (!txmCorpusDirectory.exists()) {

			return false;

		}

		File[] files = txmCorpusDirectory.listFiles(IOUtils.HIDDENFILE_FILTER);

		if (files == null || files.length == 0) {

			return false;

		}

		ConsoleProgressBar cpb = new ConsoleProgressBar(files.length);

				HashSet<String> errors = converter.getNoMatchValues();

				if (errors.size() > 0) {

					int i = 0;

					for (String error : errors) {

						if (i >= 10) break;

					}

					if (errors.size() > 10) {

						try {

							File errorFile = new File(Toolbox.getTxmHomePath(), "errors.txt");

							IOUtils.write(errorFile, StringUtils.join(errors, "\t"));

						}

						catch (Exception e) {

							e.printStackTrace();

				tmpFile.renameTo(xmlFile);

				if (tmpFile.exists()) {

					return false;

				}

			}

			else {

				return false;

			}

		}

		return true;

	}

}

import javax.xml.stream.XMLStreamReader;

import org.txm.importer.StaxIdentityParser;

public class XMLTXMFileRuledConversion extends StaxIdentityParser {

				String value = parser.getAttributeValue(i);

				if (oldType != null && oldType.equals(att)) {

					if (converter != null) {

						newValue = converter.getValue(parser, localname, att, value);

					}

					else {

			}

			if (oldType == null && converter != null) {

				newValue = converter.getValue(parser, localname, null, null);

			}

			if (newValue != null) {

				writeAttribute(null, newType, newValue);

			}

		}

import javax.xml.stream.XMLStreamException;

import javax.xml.stream.XMLStreamWriter;

import org.txm.annotation.kr.core.repository.AnnotationType;

import org.txm.importer.StaxIdentityParser;

/**

 * The Class AnnotationStandoffInjector.

			if (localname.equals("TEI")) {

				try {

					for (String author : allannotations.keySet()) {

						File currentXmlFile = new File(xmlStandOffDirectory, filename.substring(0, filename.length() - 4) + "_" + currentAuthor + "_annotations.xml");

						// write start of the stand-off file

					}

				}

				catch (Exception e) {

				}

			}

			super.processEndElement();

	 * @throws InvalidCqpIdException

	 * @throws XMLStreamException

	 */

		boolean show_debug = Log.getLevel().intValue() < Level.INFO.intValue();

		AnnotationSyMoGIHWriter annotationstdoff = new AnnotationSyMoGIHWriter(textid, currentXMLFile, xmlStandOffDirectory, types, show_debug);

				return true;

			}

			else {

			}

		}

		else {

		}

		return false;

	public boolean writeAnnotationsInStandoff(File resultZipFile) throws IOException, CqiServerError, CqiClientException, InvalidCqpIdException, XMLStreamException {

		List<String> textsIds = Arrays.asList(corpus.getCorpusTextIdsList());

		File resultDirectory = new File(Toolbox.getTxmHomePath(), "results/" + corpus.getID() + "_annotations");

		DeleteDir.deleteDirectory(resultDirectory);

		resultDirectory.mkdirs();

		if (!(resultDirectory.exists() && resultDirectory.canWrite())) {

			return false;

		}

		File inputDirectory = corpus.getProjectDirectory();

		File corpusTxmDirectory = new File(inputDirectory, "txm/" + corpus.getID());

		for (String textid : textsIds) {

			File currentXMLFile = new File(corpusTxmDirectory, textid + ".xml");

			if (!currentXMLFile.exists()) {

				return false;

			}

			File currentXMLStandoffFile = new File(resultDirectory, textid + ".xml"); // To Be Changed ?

			if (!writeTextAnnotationToSyMoGIH(textid, currentXMLFile, currentXMLStandoffFile, resultDirectory)) {

				return false;

			}

		}

		Zip.compress(resultDirectory, resultZipFile, new ConsoleProgressBar(1));

		DeleteDir.deleteDirectory(resultDirectory);

		return resultZipFile.exists();

	}

		DeleteDir.deleteDirectory(tmpXMLTXMDirectory);

		tmpXMLTXMDirectory.mkdirs();

		if (!(tmpXMLTXMDirectory.exists() && tmpXMLTXMDirectory.canWrite())) {

			return false;

		}

		// DeleteDir.deleteDirectory(tmpXMLTXMDirectory);

		previousXMLTXMDirectory.mkdirs();

		if (!(previousXMLTXMDirectory.exists() && previousXMLTXMDirectory.canWrite())) {

			return false;

		}

import org.txm.Toolbox;

import org.txm.importer.StaxIdentityParser;

import org.txm.importer.ValidateXml;

/**

 * The Class AnnotationInjection.

		});

		if (debug) {

		}

	}

				for (Annotation a : currentStartAnnotations) {

					if (!"#del".equals(a.getValue())) {

						if (debug) {

						}

						writeStartAnnotation(a);

					}

					else {

						if (debug)

						currentEndAnnotations = annotationsToAddByEndPos.get(a.getEnd());

						// System.out.println(" shall we need to change annotation attribute : "+a.getValue()+

						// " | currentEndAnnotations : "+currentEndAnnotations);

						if (currentEndAnnotations == null) {

						}

						else {

							currentEndAnnotations.remove(a);

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

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

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

public class CQPAnnotationManager {

				return struc_str[0];

			}

			else { // should not happens

				return null;

			}

		}

						}

						else {

							monitor.worked(50);

							return Status.CANCEL_STATUS;

						}

					} else {

			Object first = CorporaView.getFirstSelectedObject();

			if (!(first instanceof org.txm.searchengine.cqp.corpus.CQPCorpus)) {

				return null;

			}

						export(exportDirectory, mainCorpus, unit_type);

					}

					catch (ThreadDeath e) {

					}

					catch (Throwable e) {

						Log.printStackTrace(e);

						return Status.CANCEL_STATUS;

					}

			return null;

		}

		catch (Throwable e) {

			Log.printStackTrace(e);

		}

		return null;

import org.txm.annotation.urs.URSCorpora;

import org.txm.rcp.views.corpora.CorporaView;

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

import visuAnalec.VisuMain;

import visuAnalec.donnees.Corpus;

		Object first = CorporaView.getFirstSelectedObject();

		if (!(first instanceof org.txm.searchengine.cqp.corpus.CQPCorpus)) {

			return null;

		}

import org.txm.annotation.urs.view.ElementPropertiesView;

import org.txm.rcp.views.corpora.CorporaView;

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

import visuAnalec.VisuMain;

import visuAnalec.donnees.Corpus;

		Object first = CorporaView.getFirstSelectedObject();

		if (!(first instanceof org.txm.searchengine.cqp.corpus.CQPCorpus)) {

			return null;

		}

import visuAnalec.fichiers.FichiersTEI;

public class ImportTEICorpus  extends AbstractHandler {

	@Option(name="xmlFile",usage="an example file", widget="File", required=true, def="text.xml")

	File xmlFile;

	private String name;

	/* (non-Javadoc)

	 * @see org.eclipse.core.commands.AbstractHandler#execute(org.eclipse.core.commands.ExecutionEvent)

	 */

		try {

			// Open the parameters input dialog box

			if (!ParametersDialog.open(this)) return null;

			// END OF PARAMETERS

			if (!(xmlFile.exists())) {

				return null;

			}

			name = xmlFile.getName();

			int idx = name.indexOf("."); //$NON-NLS-1$

			name = name.substring(0, idx);

			name = AsciiUtils.buildId(name);

			File srcDir = new File(xmlFile.getParentFile(), name);

			DeleteDir.deleteDirectory(srcDir);

			srcDir.mkdir();

			if (!srcDir.exists()) {

				return null;

			}

			// write the TXT file WITH paragraphs

			File txtFile = new File(srcDir, name+".txt"); //$NON-NLS-1$

			Corpus tmpAnalecCorpus = new Corpus(); // need a temporary corpus

			if (!FichiersTEI.convertir(xmlFile, new File("/tmp"), tmpAnalecCorpus)) { //$NON-NLS-1$

				return null;

			}

			final String texte = tmpAnalecCorpus.getTexte();

			IOUtils.write(txtFile, newTexte.toString());

			if (!txtFile.exists()) {

				return null;

			}

			Project project = new Project(Toolbox.workspace, name.toUpperCase());

			project.setSourceDirectory(srcDir.getAbsolutePath());

			project.setImportModuleName("txt");

			JobHandler job = ExecuteImportScript.executeScript(project);

			if (job == null) { // job is scheduled in ExecuteImportScript.executeScript

				return null;

			}

			JobHandler job2 = new JobHandler(Messages.ImportTEICorpus_16) {

				@Override

				protected IStatus run(IProgressMonitor monitor) {

					try {

					} catch (Exception e) {

						Log.printStackTrace(e);

						return Status.CANCEL_STATUS;

					}

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

import org.txm.rcp.views.corpora.CorporaView;

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

import visuAnalec.donnees.Corpus;

import visuAnalec.fichiers.FichiersJava;

		Object first = CorporaView.getFirstSelectedObject();

		if (!(first instanceof org.txm.searchengine.cqp.corpus.CQPCorpus)) {

			return null;

		}

		MainCorpus mainCorpus = ((org.txm.searchengine.cqp.corpus.CQPCorpus)first).getMainCorpus();

		Corpus corpus = URSCorpora.getCorpus(mainCorpus);

		if (!ParametersDialog.open(this)) return null;

	public static boolean load(File ecfile, Corpus corpus) {

		if (!(ecfile.exists())) {

			return false;

		}

		File fichierCorpus = ecfile;

		if (!FichiersJava.ouvrirCorpus(corpus, fichierCorpus, false)) {

			return false;

		}

		return true;

	}

}

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

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

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

import visuAnalec.donnees.Corpus;

import visuAnalec.fichiers.FichiersGlozz;

	public static boolean doImport(File aafile, File aamfile, File acfile) throws CqiClientException, IOException, CqiServerError {

		if (!(aafile.exists() && aafile.exists() && aafile.exists())) {

			return false;

		}

		Object first = CorporaView.getFirstSelectedObject();

		if (!(first instanceof org.txm.searchengine.cqp.corpus.CQPCorpus)) {

			return false;

		}

		Corpus analecCorpus = URSCorpora.getCorpus(mainCorpus);

		analecCorpus.clearAll(); // remove all : annotations, structure

		if (!FichiersGlozz.importerModeleGlozz(analecCorpus, aamfile)) {

			return false;

		}

		if (!FichiersGlozz.importerGlozz(analecCorpus, acfile, aafile)) {

			return false;

		}

		URSAnnotationReIndexer aari = new URSAnnotationReIndexer(mainCorpus, analecCorpus);

		if (!aari.process()) {

			return false;

		}

		URSCorpora.saveCorpus(analecCorpus);

		return true;

	}

}

			Object first = CorporaView.getFirstSelectedObject();

			if (!(first instanceof org.txm.searchengine.cqp.corpus.CQPCorpus)) {

				return null;

			}

					try {

						this.runInit(monitor);

						if (!export(true, outputDirectory, createArchive, monitor, mainCorpus, analecCorpus, vue, copyXMLTXMFiles)) {

							return Status.CANCEL_STATUS;

						} else {

							return Status.OK_STATUS;

						}

					} catch (Exception e) {

						Log.printStackTrace(e);

						return Status.CANCEL_STATUS;

					}

			job.schedule();

		} catch (Exception e) {

			Log.printStackTrace(e);

		}

		return null;

				return; // nothing to do

			}

		}

		File previousURSMacroDirectory = new File(Toolbox.getTxmHomePath(), "scripts/groovy/user/org/txm/macro/analec"); //$NON-NLS-1$

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

			File back = new File(previousURSMacroDirectory.getParentFile(), "urs_"+saved); //$NON-NLS-1$

			if (back.exists()) {

				return;

			}

			previousURSMacroDirectory.renameTo(back);

		}

		File macroDirectory = new File(Toolbox.getTxmHomePath(), "scripts/groovy/user/org/txm/macro/analec"); //$NON-NLS-1$

		if (!BundleUtils.copyFiles("org.txm.annotation.urs.rcp", "src", "org/txm/macro/", "urs", macroDirectory, true)) { //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$

			return;

		}

			Object first = CorporaView.getFirstSelectedObject();

			if (!(first instanceof org.txm.searchengine.cqp.corpus.CQPCorpus)) {

				return null;

			}

						}

						if (!importer(monitor, directory, aamFile, true, mainCorpus, analecCorpus, vue)) {

							return Status.CANCEL_STATUS;

						} else {

							return Status.OK_STATUS;

						}

					} catch (Throwable e) {

						Log.printStackTrace(e);

						return Status.CANCEL_STATUS;

					}

			job.schedule();

		} catch (Exception e) {

			Log.printStackTrace(e);

		}

		return null;

		boolean ret = importer.process();

		if (ret) {

			mainCorpus.setIsModified(true);

			CorporaView.refreshObject(mainCorpus);

		}

			// END OF PARAMETERS

			if (!glozzDirectory.exists()) {

				return null;

			}

			}

			final File srcDir = new File(glozzDirectory, name);

			DeleteDir.deleteDirectory(srcDir);

			srcDir.mkdir();

			final File ecDir = new File(glozzDirectory, "ec"); //$NON-NLS-1$

			DeleteDir.deleteDirectory(ecDir);

			ecDir.mkdir();

			if (!srcDir.exists()) {

				return null;

			}

			if (!ecDir.exists()) {

				return null;

			}

			});

			if (aaFiles == null || aaFiles.length == 0) {

				return false;

			}

			if (acFiles == null || acFiles.length == 0) {

				return false;

			}

			if (aaFiles.length != acFiles.length) {

				return false;

			}

			Arrays.sort(acFiles);

			Arrays.sort(aaFiles);

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

				Corpus tmpAnalecCorpus = new Corpus(); // need a temporary corpus

				if (!FichiersGlozz.importerGlozz(tmpAnalecCorpus, acFile, aaFile)) {

					return null;

				}

				FichiersJava.enregistrerCorpus(tmpAnalecCorpus, ecFile); // write for later

				if (!txtFile.exists()) {

					return null;

				}

			}

			JobHandler job = ExecuteImportScript.executeScript(project);

			if (job == null) { // job is scheduled in ExecuteImportScript.executeScript

				return null;

			}

					try {

						MainCorpus corpus = CorpusManager.getCorpusManager().getCorpus(name.toUpperCase());

						if (corpus == null) {

							return Status.CANCEL_STATUS;

						}

						corpus.compute(false);

							FichiersJava.concatener(ecFile, analecCorpus);

						}

						if (!FichiersGlozz.importerModeleGlozz(analecCorpus, aamfile)) {

							return Status.CANCEL_STATUS;

						}

						//

						// return null;

						// }

						URSCorpora.removeCorpus(corpus); // remove old corpus if any

						URSAnnotationReIndexer aari = new URSAnnotationReIndexer(corpus, analecCorpus);

						if (!aari.process()) {

							return Status.CANCEL_STATUS;

						}

						URSCorpora.saveCorpus(analecCorpus);

						URSCorpora.getVue(analecCorpus).retablirVueParDefaut();

						analecCorpus.setTexte(""); // free memory //$NON-NLS-1$

						DeleteDir.deleteDirectory(ecDir); // cleaning

						DeleteDir.deleteDirectory(srcDir); // cleaning

						return Status.OK_STATUS;

					}

					catch (Exception e) {

						Log.printStackTrace(e);

						return Status.CANCEL_STATUS;

					}

import java.util.List;

import java.util.TreeMap;

import org.txm.annotation.kr.core.Annotation;

import org.txm.annotation.kr.core.AnnotationManager;

import org.txm.annotation.kr.core.KRAnnotationEngine;

				annotationsPerMatch = am.getAnnotationsForMatches(viewAnnotation, subsetMatch, overlapAnnotation);

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

			} catch (Exception e) {

				Log.printStackTrace(e);

			}

		}

	protected void affectAnnotationValues(final List<? extends Match> matches, final AnnotationType type, final String svalue, JobHandler job) {

		value_to_add = null; // reset

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

			return;

		}

		if (type == null) return; // no type, no annotation

							NLS.bind(KRAnnotationUIMessages.youAreAboutToAnnotateP0ElementsContinue, matches.size()));

					if (dialog.open() == ConfirmDialog.CANCEL) {

						matches.clear();

					}

				}

				@Override

				public void run() {

					String mess = KRAnnotationUIMessages.bind(KRAnnotationUIMessages.noValueFoundWithTheP0Id, svalue);

				}

			});

			return;

			// concordance.reloadCurrentLines();

		}

		catch (Exception e1) {

			Log.printStackTrace(e1);

			return;

		}

					return Status.CANCEL_STATUS;

				}

				catch (ThreadDeath td) {

					return Status.CANCEL_STATUS;

				}

	protected void deleteAnnotationValues(List<Match> matches, AnnotationType type, JobHandler job) {

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

			return;

		}

			}

		}

		catch (Exception e1) {

			Log.printStackTrace(e1);

			return;

		}

					editor.refresh(false);

				}

				catch (Exception e) {

				}

			}

		});

					return Status.CANCEL_STATUS;

				}

				catch (ThreadDeath td) {

					return Status.CANCEL_STATUS;

				}

					updateAnnotationWidgetStates();

				}

				else {

				}

			}

			// onAnnotationTypeSelected(null);

		}

		else {

		}

	}

				// ?")

				JobHandler saveJob = SaveAnnotations.save(WordAnnotationToolbar.this.corpus.getMainCorpus());

				if (saveJob == null || saveJob.getResult() == Status.CANCEL_STATUS) {

					return false;

				}

				else {

					try {

						return krl.getValues(t).toArray();

					} catch (Exception e) {

						Log.printStackTrace(e);

					}

				}

					try {

						return krl.hasValues(t);

					} catch (Exception e) {

						Log.printStackTrace(e);

					}

				}

import java.util.List;

import java.util.TreeMap;

import org.txm.annotation.kr.core.Annotation;

import org.txm.annotation.kr.core.AnnotationManager;

import org.txm.annotation.kr.core.KRAnnotationEngine;

				annotationsPerMatch = am.getAnnotationsForMatches(viewAnnotation, subsetMatch, overlapAnnotation);

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

			} catch (Exception e) {

				Log.printStackTrace(e);

			}

		}

					return Status.CANCEL_STATUS;

				}

				catch (ThreadDeath td) {

					return Status.CANCEL_STATUS;

				}

	protected void deleteAnnotationValues(List<? extends Match> matches, AnnotationType type, JobHandler job) {

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

			return;

		}

			}

		}

		catch (Exception e1) {

			Log.printStackTrace(e1);

			return;

		}