Laboratoire ICAR » Plateforme TXM

eclipse.preferences.version=1

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

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

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

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

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

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

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

<classpath>

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

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

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

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

</classpath>

Manifest-Version: 1.0

Bundle-ManifestVersion: 2

Bundle-Name: Annotation

Bundle-SymbolicName: org.txm.annotation.core

Bundle-Version: 1.0.0.qualifier

Bundle-Activator: org.txm.annotation.Activator

Require-Bundle: org.eclipse.ui,

 org.eclipse.core.runtime,

 org.txm.core;bundle-version="0.7.0"

Bundle-RequiredExecutionEnvironment: JavaSE-1.6

Bundle-ActivationPolicy: lazy

Export-Package: org.txm.annotation,

 org.txm.annotation.conversion,

 org.txm.annotation.repository,

 org.txm.annotation.storage.temporary

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

<projectDescription>

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

	<comment></comment>

	<projects>

	</projects>

	<buildSpec>

		<buildCommand>

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

			<arguments>

			</arguments>

		</buildCommand>

		<buildCommand>

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

			<arguments>

			</arguments>

		</buildCommand>

		<buildCommand>

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

			<arguments>

			</arguments>

		</buildCommand>

	</buildSpec>

	<natures>

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

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

	</natures>

</projectDescription>

package org.txm.annotation;

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import java.net.MalformedURLException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import javax.xml.stream.XMLInputFactory;

import javax.xml.stream.XMLOutputFactory;

import javax.xml.stream.XMLStreamException;

import javax.xml.stream.XMLStreamWriter;

import org.txm.annotation.repository.AnnotationType;

import org.txm.importer.StaxIdentityParser;

/**

 * The Class AnnotationStandoffInjector.

 *

 * @author sgedzelman, mdecorde

 *

 * copy a XML-TXM file without annotations elements

 * and creates annotations XML-TEI-SymoGIH annotation files for each annotation author

 * 

 */

public class AnnotationSyMoGIHWriter extends StaxIdentityParser {

	File xmlStandOffDirectory;

	boolean debug = false;

	String currentRef ;

	String currentAuthor ;

	String currentDate;

	String currentStartPos ;

	String currentEndPos ;

	//read xmlFile, to find annotations and update/write to xmlstandofffile

	//order annotations by annotator

	////// order annotations by date

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

	ArrayList<String> positions;

	HashMap<String, ArrayList<String>> annotationsPositions;

	XMLStreamWriter currentWriter;

	XMLStreamWriter standoffWriter;

	String currentType;

	boolean startAnnotation = false;

	private String filename;

	// author -> date -> annotation_values

	HashMap<String, HashMap<String, ArrayList<String[]>>> allannotations = new HashMap<String, HashMap<String, ArrayList<String[]>>>();

	HashMap<String, HashMap<String, ArrayList<ArrayList<String>>>> allannotationspositions = new HashMap<String, HashMap<String, ArrayList<ArrayList<String>>>>();

	private String textid;

	/**

	 * 

	 * @param xmlStandOffFile

	 * @param tokenAnnotations 

	 * @param annotationsToAddByStartPos

	 * @param annotationsToAddByEndPos

	 * @param corpus_start_position

	 * @param debug

	 * @throws XMLStreamException 

	 * @throws IOException 

	 */

	public AnnotationSyMoGIHWriter(String textid, File xmlFile, File xmlStandOffDirectory, List<AnnotationType> types, boolean debug) throws IOException, XMLStreamException {

		super(xmlFile.toURI().toURL()); // init reader and writer

		this.textid = textid;

		this.filename = xmlFile.getName();

		this.debug = debug;

		this.xmlStandOffDirectory = xmlStandOffDirectory;

		factory = XMLInputFactory.newInstance();

		annotationsPositions = new HashMap<String, ArrayList<String>>();

		//System.out.println("AnnotationStandoff -  ");

		for (AnnotationType type : types){

			this.types.add(type.getId()); //.getName().toLowerCase());

			//System.out.println("Annotation Types in TXM : "+type.getName().toLowerCase() +" vs "+ type.getId());

		}

	}

	/*<TEI xmlns="http://www.tei-c.org/ns/1.0">

    <teiHeader>

        <fileDesc>

            <titleStmt>

                <title>Title</title>

            </titleStmt>

            <publicationStmt>

                <p>Publication Information</p>

            </publicationStmt>

            <sourceDesc>

                <p>Ce document permet l'annotation sémantique de tous les textes concernant l'association avec des unités de connaissance</p>

            </sourceDesc>

        </fileDesc>

    </teiHeader>

    <text>

        <body>

            <div>

                <div>

                    <!-- La date dans le header indique la date d'annotation -->

                    <head>

                        <date type="annotation_date" when="2016-06-16"/>

                    </head>

                    <span type="identification d'entités nommées" ana="CoAc56389" 

                          target="#w_article_baip_1254-0714_1850_num_01_005_974_tei_2152 

                                  #w_article_baip_1254-0714_1850_num_01_005_974_tei_2153 

                                  #w_article_baip_1254-0714_1850_num_01_005_974_tei_2154 

                                  #w_article_baip_1254-0714_1850_num_01_005_974_tei_2155 

                                  #w_article_baip_1254-0714_1850_num_01_005_974_tei_2156" />

                </div>

            </div>

         </body>

      </text>

 </TEI>*/

	protected void processStartElement() throws XMLStreamException, IOException {

		//<coac author="gazelledess" ref="CoAc397" start="5" end="5">

		/*if(localname.startsWith("actr")){

			System.out.println("Check existence of actr in Corpus !!!! "+localname);

		}*/

		boolean foundAnnot = false;

		if (types.contains(localname) && parser.getPrefix().equals("txm")) { // don't write txm annotation elements

			//System.out.println(" START "+ localname);

			foundAnnot = true;

			currentType = localname;

			//<txm:actr author="gazelledess" ref="PhileasFogg" date="2016-09-05" start="56" end="57">

			currentAuthor = parser.getAttributeValue(null, "author");

			currentRef = parser.getAttributeValue(null, "ref");

			currentStartPos = parser.getAttributeValue(null, "start");

			currentEndPos = parser.getAttributeValue(null, "end");

			currentDate = parser.getAttributeValue(null, "date");

			//annotation is here

			startAnnotation = true;

			positions = new ArrayList<String>();

			annotationsPositions.put(currentType, positions);

			// initialize allannotations

			if (!allannotations.containsKey(currentAuthor)) {

				allannotations.put(currentAuthor, new HashMap<String, ArrayList<String[]>>());

				allannotationspositions.put(currentAuthor, new HashMap<String, ArrayList<ArrayList<String>>>());

			}

			HashMap<String, ArrayList<String[]>> authorsAnnotation = allannotations.get(currentAuthor);

			HashMap<String, ArrayList<ArrayList<String>>> authorsAnnotationPositions = allannotationspositions.get(currentAuthor);

			if (!authorsAnnotation.containsKey(currentDate)) {

				authorsAnnotation.put(currentDate, new ArrayList<String[]>());

				authorsAnnotationPositions.put(currentDate, new ArrayList<ArrayList<String>>());

			}

			storeAnnotation();

		}

		if (!foundAnnot) {

			super.processStartElement(); /// continue writing in file all elements, except the tags that are now in stand-off files

			// get words ids of the current annotations

			if (localname.equals("w") && startAnnotation) {

				String id = parser.getAttributeValue(null, "id");

				for (String typeIn : annotationsPositions.keySet()) {

					positions = annotationsPositions.get(typeIn);

					positions.add(id);

					//System.out.println("Positions of w id="+posW+" for ["+typeIn+"] ");

				}

			}

		}

	}

	/**

	 * ends the current author stand-off file

	 * @param currentWriter

	 */

	private void writeEndStandOffFile(XMLStreamWriter currentWriter){

		//System.out.println("writeEndStandOffFile ...");

		try {

			currentWriter.writeEndElement(); 

			currentWriter.writeEndDocument();

			currentWriter.flush();

			currentWriter.close();

		} catch (XMLStreamException e) {

			e.printStackTrace();

		}

	}

	/**

	 * Create the stand-off file for one author

	 * @param file

	 * @return

	 */

	private XMLStreamWriter writeStartStandOffFile(File file){

		//System.out.println("writeStartStandOffFile ...");

		String ns = "http://www.tei-c.org/ns/1.0";    

		XMLOutputFactory output = XMLOutputFactory.newInstance();

		XMLStreamWriter writer = null ;

		try {

			writer = output.createXMLStreamWriter(new FileWriter(file));

			writer.writeStartDocument();

			writer.setPrefix("tei", ns);

			writer.setDefaultNamespace(ns);

			writer.writeStartElement("TEI");

			writer.writeStartElement("teiHeader");

			writer.writeStartElement("fileDesc");

			writer.writeStartElement("titleStmt");

			writer.writeStartElement("title");

			writer.writeCharacters(textid); 

			writer.writeEndElement(); // title

			writer.writeEndElement(); // titleStmt

			writer.writeStartElement("publicationStmt");

			writer.writeStartElement("p");

			writer.writeCharacters("PUBLICATION INFO à renseigner");

			writer.writeEndElement(); // p

			writer.writeEndElement(); // publicationStmt

			writer.writeStartElement("sourceDesc");

			writer.writeStartElement("p");

			writer.writeCharacters("Ce document permet l'annotation sémantique de tous les textes, par auteur");

			writer.writeEndElement(); // p

			writer.writeEndElement(); // sourceDesc

			writer.writeEndElement(); // </fileDesc>

			writer.writeStartElement("encodingDesc");

			writer.writeStartElement("projectDesc");

			writer.writeStartElement("p");

			writer.writeCharacters("Annotations created by "+currentAuthor+", for the use in Symogih XML platform");

			writer.writeEndElement(); // p

			writer.writeEndElement(); // </projectDesc>

			writer.writeEndElement(); // </encodingDesc>

			writer.writeEndElement(); // </teiHeader>

			writer.writeStartElement("text");

			writer.writeStartElement("body");

			writer.writeCharacters("\n");

			writer.writeStartElement("div");

			writer.writeCharacters("\n");

		} catch (XMLStreamException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		} catch (IOException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

		return writer;

	}

	private void storeAnnotation() {

		allannotations.get(currentAuthor).get(currentDate).add(new String[]{currentDate, currentRef, currentType});

	}

	private void storeAnnotationPositions() {

		allannotationspositions.get(currentAuthor).get(currentDate).add(positions);

	}

	/**

	 * write stand-off annotation

	 */

	private void writeStartAnnotationToStandoffFile(String[] data, ArrayList<String> positions) {

		//System.out.println("writeStartAnnotationToStandoffFile ...");

		try {

			currentWriter.writeStartElement("span");

			currentWriter.writeAttribute("type","named_entities_identifications");

			currentWriter.writeAttribute("ana", data[1]);

			StringBuffer listWids = new StringBuffer();

			for (String posW : positions) {

				listWids.append("#"+posW+" ");

			}

			currentWriter.writeAttribute("target", listWids.toString().trim());

			currentWriter.writeComment("type="+data[2]);

			currentWriter.writeEndElement(); // span

			currentWriter.writeCharacters("\n");

		} catch (XMLStreamException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	}

	protected void processEndElement() throws XMLStreamException {

		boolean foundAnnot = false;

		if (types.contains(localname) && parser.getPrefix().equals("txm")) { // skip annotation end element

			//System.out.println(" END "+ localname);

			foundAnnot = true;

			//annotation ends here

			storeAnnotationPositions();

			if (annotationsPositions.containsKey(localname)) {

				annotationsPositions.remove(localname);

			}

			startAnnotation = false;

		}

		if (!foundAnnot) {

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

				try {

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

						System.out.println("    author="+author);

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

						// write start of the stand-off file

						currentWriter = writeStartStandOffFile(currentXmlFile);

						// write annotations grouped per date

						HashMap<String, ArrayList<String[]>> dates = allannotations.get(author);

						HashMap<String, ArrayList<ArrayList<String>>> datesPositions = allannotationspositions.get(author);

						for (String date : datesPositions.keySet()) {

							ArrayList<String[]> datas = dates.get(date);

							ArrayList<ArrayList<String>> positions = datesPositions.get(date);

							currentWriter.writeStartElement("div");

							currentWriter.writeCharacters("\n");

							currentWriter.writeStartElement("head");

							currentWriter.writeStartElement("date");

							currentWriter.writeAttribute("type","annotation_date");

							currentWriter.writeAttribute("when", date); 

							currentWriter.writeEndElement(); // date

							currentWriter.writeEndElement(); // head

							currentWriter.writeCharacters("\n");

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

								writeStartAnnotationToStandoffFile(datas.get(i), positions.get(i));

							}

							currentWriter.writeEndElement(); // div

							currentWriter.writeCharacters("\n");

						}

						// write the end of the stand-off file

						writeEndStandOffFile(currentWriter);

					}

				}

				catch(Exception e){

					System.out.println("Current writer "+currentWriter);

				}

			}

			super.processEndElement();

		}

	}

	public static void main(String strs[]){

		try {

		File xmlFile = new File("/home/mdecorde/TXM/corpora/TDM80J/txm/TDM80J", "tdm80j.xml");

		File outfile = new File(xmlFile.getParentFile(), "tdm80j-tei.xml");

		File xmlStandOffDirectory = xmlFile.getParentFile();

		List<AnnotationType> types = new ArrayList<AnnotationType>();

		types.add(new AnnotationType("local","actr_id", "actr"));

		AnnotationSyMoGIHWriter annotStdff;

		try {

			annotStdff = new AnnotationSyMoGIHWriter("TDBM80J", xmlFile, xmlStandOffDirectory, types, true);

			annotStdff.process(outfile);

		} catch (MalformedURLException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

		} catch(Exception e) {

			e.printStackTrace();

		}

	}

}

package org.txm.annotation;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.logging.Level;

import javax.xml.stream.XMLStreamException;

import org.apache.commons.lang.StringUtils;

import org.txm.Toolbox;

import org.txm.annotation.repository.AnnotationEffect;

import org.txm.annotation.repository.AnnotationType;

import org.txm.annotation.repository.KnowledgeRepository;

import org.txm.core.preferences.TBXPreferences;

import org.txm.importer.ValidateXml;

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

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

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

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

import org.txm.stat.utils.ConsoleProgressBar;

import org.txm.utils.DeleteDir;

import org.txm.utils.logger.Log;

import org.txm.utils.zip.Zip;

import org.w3c.dom.Document;

import org.w3c.dom.Node;

public class AnnotationWriter {

	MainCorpus corpus;

	private List<AnnotationType> types;

	private KnowledgeRepository defaultKR;

	public AnnotationWriter(MainCorpus corpus){

		this.corpus = corpus;

		defaultKR = corpus.getKnowledgeRepository(corpus.getKnowledgeRepositoryNames().get(0));

		types = defaultKR.getAllAnnotationTypes();

	}

	/**

	 * process a text to build standoff files

	 * 

	 * @param textid

	 * @param currentXMLFile

	 * @param currentXMLStandoffFile

	 * @param xmlStandOffDirectory

	 * @return

	 * @throws IOException

	 * @throws CqiServerError

	 * @throws CqiClientException

	 * @throws InvalidCqpIdException

	 * @throws XMLStreamException 

	 */

	protected boolean writeTextAnnotationToSyMoGIH(String textid, File currentXMLFile, File currentXMLStandoffFile, File xmlStandOffDirectory) throws IOException, CqiServerError, CqiClientException, InvalidCqpIdException, XMLStreamException{

		System.out.println("  text="+textid);

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

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

		///rather test on the new xml standoff files

		if (annotationstdoff.process(currentXMLStandoffFile)) {

			if (ValidateXml.test(currentXMLStandoffFile)) { //TODO ALSO check if annotations are well-written 

				return true;

			} else {

				System.out.println("Error: result file "+currentXMLStandoffFile+" is malformed.");

			}

		} else {

			System.out.println("Error: while processing "+currentXMLStandoffFile+" in standoff dir");

		}

		return false;

	}

	/**

	 * Writing annotations in standoff files for each text of the corpus

	 * 

	 * @param allCorpusAnnotations

	 * @return

	 * @throws IOException

	 * @throws CqiServerError

	 * @throws CqiClientException

	 * @throws InvalidCqpIdException

	 * @throws XMLStreamException 

	 */

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

		List<String> textsIds = corpus.getTextsID();

		System.out.println("Exporting annotations of "+StringUtils.join(textsIds, ", ")+".");

		File resultDirectory = new File(Toolbox.getParam(TBXPreferences.USER_TXM_HOME), "results/"+corpus.getName()+"_annotations");

		DeleteDir.deleteDirectory(resultDirectory);

		resultDirectory.mkdirs();

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

			System.out.println("ERROR: could not create/write temporary directory: "+resultDirectory);

			return false;

		}

		File inputDirectory = corpus.getBaseDirectory();

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

		System.out.println("Writing annotations XML files in "+resultDirectory);

		for (String textid : textsIds) { 

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

			if (!currentXMLFile.exists()) {

				System.out.println("Error: cannot found XML file for text with id="+textid);

				return false;

			}

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

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

						System.out.println("Error while writing annotations of text "+currentXMLStandoffFile);

						return false;

			}

		}

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

		DeleteDir.deleteDirectory(resultDirectory);

		System.out.println("Annotations saved in "+resultZipFile.getAbsolutePath());

		return resultZipFile.exists();

	}

	/**

	 * 

	 * @param allCorpusAnnotations ordered annotations

	 * @return

	 * @throws IOException

	 * @throws CqiServerError

	 * @throws CqiClientException

	 * @throws InvalidCqpIdException

	 * @throws XMLStreamException 

	 */

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

		//MainCorpus corpus = CorpusManager.getCorpusManager().getCorpus(c.getName());

		System.out.println("Saving "+allCorpusAnnotations.size()+"annotations...");

		int[] end_limits = corpus.getTextEndLimits();

		int[] start_limits = corpus.getTextStartLimits();

		List<String> textsIds = corpus.getTextsID();

		File inputDirectory = corpus.getBaseDirectory();

		File txmDirectory = new File(inputDirectory, "txm/"+corpus.getName());

		ArrayList<Annotation> textAnnotations = new ArrayList<Annotation>();

		HashMap<String, ArrayList<Annotation>> annotationsPerTexts = new HashMap<String, ArrayList<Annotation>>();

		int currentText = 0;

		File currentXMLFile = new File(txmDirectory, textsIds.get(currentText)+".xml");

		//store first text

		currentXMLFile = new File(txmDirectory, textsIds.get(currentText)+".xml");

		textAnnotations = new ArrayList<Annotation>();

		annotationsPerTexts.put(textsIds.get(currentText), textAnnotations);

		// group annotations per text

		for (Annotation currentAnnot : allCorpusAnnotations) { // parse all annotations

			//System.out.println(" Annotation: "+currentAnnot);

			int pos = currentAnnot.getPK().getEndPosition();

			while (pos > end_limits[currentText]) { // while pos is not in the currentText.end 

				currentText++;

				currentXMLFile = new File(txmDirectory, textsIds.get(currentText)+".xml");

				textAnnotations = new ArrayList<Annotation>();

				annotationsPerTexts.put(textsIds.get(currentText), textAnnotations);

			}

			textAnnotations.add(currentAnnot);

		}

		File tmpXMLTXMDirectory = new File(txmDirectory.getAbsolutePath()+"_tmp");

		DeleteDir.deleteDirectory(tmpXMLTXMDirectory);

		tmpXMLTXMDirectory.mkdirs();

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

			System.out.println("ERROR: could not create directory: "+tmpXMLTXMDirectory);

			return false;

		}

		File previousXMLTXMDirectory = new File(txmDirectory.getAbsolutePath()+"_previous");

		//DeleteDir.deleteDirectory(tmpXMLTXMDirectory);

		previousXMLTXMDirectory.mkdirs();

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

			System.out.println("ERROR: could not create directory: "+previousXMLTXMDirectory);

			return false;

		}

		System.out.println("Annotations grouped per text for "+annotationsPerTexts.size()+" text"+(annotationsPerTexts.size() > 0?"s":""));

		System.out.println(" - Writing temporary XML files in: "+tmpXMLTXMDirectory);

		System.out.println(" - Copying previous version of XML files in: "+previousXMLTXMDirectory);

		// for all annotation PER TEXT, update the XML-TXM files

		currentText = 0;

		while (currentText < end_limits.length ) { // end limits : 10, 30, 45, 55, 103

			currentXMLFile = new File(txmDirectory, textsIds.get(currentText)+".xml");

			ArrayList<Annotation> allAnnotations = annotationsPerTexts.get(textsIds.get(currentText));

			if (allAnnotations != null && allAnnotations.size() > 0) {

				ArrayList<Annotation> allSegmentAnnotations = new ArrayList<Annotation>();

				ArrayList<Annotation> allTokenAnnotations = new ArrayList<Annotation>();

				KnowledgeRepository defaultKR = corpus.getKnowledgeRepository(corpus.getKnowledgeRepositoryNames().get(0));

				System.out.println("Using KR="+defaultKR);

				for (Annotation a : allAnnotations) {

					AnnotationType type = defaultKR.getType(a.getType());

					if (type != null) {

						if (AnnotationEffect.SEGMENT.equals(type.getEffect())) {

							allSegmentAnnotations.add(a);

						} else if (AnnotationEffect.TOKEN.equals(type.getEffect())) {

							allTokenAnnotations.add(a);

						} else {

							System.out.println("Annotation "+a+" with type="+a.getType()+" not found in default KR="+defaultKR);

						}

					} else {

						System.out.println("Warning: unknowed type: "+a.getType());

					}

				}

				if (!writeAnnotationsInFile(currentXMLFile, start_limits[currentText], 

						allSegmentAnnotations, allTokenAnnotations, 

						tmpXMLTXMDirectory, previousXMLTXMDirectory)) {

					System.out.println("Error while writing annotations of text "+currentXMLFile);

					return false;

				}

			}

			currentText++;

		}

		return true;

	}		

	//writeAnnotationInStandoffFile(currentXMLStandoffFile, allAnnotations, annotator, tmpXMLTXMDirectory, previousXMLTXMDirectory))

	protected boolean writeAnnotationsInFile(File xmlFile, int text_start_position, 

			ArrayList<Annotation> segmentAnnotations, ArrayList<Annotation> tokenAnnotations, File tmpXMLTXMDirectory, File previousXMLTXMDirectory) throws CqiClientException, IOException, CqiServerError, InvalidCqpIdException, XMLStreamException{

		System.out.println("Writing annotations for text "+xmlFile+" segment annotations="+segmentAnnotations.size()+" token annotations="+tokenAnnotations.size());

		System.out.println(segmentAnnotations);

		System.out.println(tokenAnnotations);

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

		AnnotationInjector annotationInjector = new AnnotationInjector(xmlFile, segmentAnnotations, tokenAnnotations, text_start_position, show_debug);

		File tmpfile = new File(tmpXMLTXMDirectory, xmlFile.getName());

		File previousfile = new File(previousXMLTXMDirectory, xmlFile.getName());

		if (annotationInjector.process(tmpfile)) {

			if (ValidateXml.test(tmpfile)) { //TODO ALSO check if annotations are well-written 

				previousfile.delete(); // in case there is one

				if (!previousfile.exists() && xmlFile.renameTo(previousfile)) {

					tmpfile.renameTo(xmlFile);

					return true;

				} else {

					System.out.println("Error: could not replace XML-TXM file: "+xmlFile+" with "+tmpfile);

				}

			} else {

				System.out.println("Error: result file "+tmpfile+" is malformed.");

			}

		} else {

			System.out.println("Error: while processing "+xmlFile+" in temp dir");

		}

		return false;

	}

}

package org.txm.annotation;

import java.io.File;

import java.io.IOException;

import java.net.MalformedURLException;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import javax.xml.stream.XMLInputFactory;

import javax.xml.stream.XMLStreamException;

import org.txm.importer.StaxIdentityParser;

import org.txm.importer.ValidateXml;

import org.txm.objects.BaseParameters;

/**

 * The Class AnnotationInjection.

 *

 * @author mdecorde

 *

 * inject annotation from a stand-off file into a xml-tei-txm file "id"

 */

public class AnnotationInjector extends StaxIdentityParser {

	File xmlFile;

	HashMap<Integer, List<Annotation>> annotationsToAddByStartPos; // contains

																	// annotation

																	// to write

	HashMap<Integer, List<Annotation>> annotationsToAddByEndPos;

	List<Annotation> currentStartAnnotations;

	List<Annotation> currentEndAnnotations;

	HashMap<String, Annotation> currentTokenAnnotations = new HashMap<String, Annotation>();

	int n = 0;

	boolean debug = false;

	String data; // the word id properties to add/replace

	String newform = null;

	String wordId;

	boolean inW = false;

	String anaType;

	int position_counter = 0;

	String closeNext = null; // the next close tag to delete

	ArrayList<String> openedElements = new ArrayList<String>(); // to ensure to

																// delete the

																// right element

	private List<Annotation> previousEndAnnotations;

	private ArrayList<Annotation> tokenAnnotations;

	String user;

	/**

	 * 

	 * @param xmlFile

	 * @param tokenAnnotations

	 * @param annotationsToAddByStartPos

	 * @param annotationsToAddByEndPos

	 * @param corpus_start_position

	 * @param debug

	 * @throws XMLStreamException 

	 * @throws IOException 

	 */

	public AnnotationInjector(File xmlFile, List<Annotation> segmentAnnotations, ArrayList<Annotation> tokenAnnotations, int corpus_start_position, boolean debug) throws IOException, XMLStreamException {

		super(xmlFile.toURI().toURL()); // init reader and writer

		this.user = System.getProperty("user.name");

		this.debug = debug;

		this.xmlFile = xmlFile;

		this.n = 0;

		// println ""+records.size()+" lines to process..."

		this.position_counter = corpus_start_position;

		factory = XMLInputFactory.newInstance();

		// preparing annotations to being written in the right inclusion order

		annotationsToAddByStartPos = new HashMap<Integer, List<Annotation>>();

		annotationsToAddByEndPos = new HashMap<Integer, List<Annotation>>();

		for (Annotation a : segmentAnnotations) {

			if (!annotationsToAddByStartPos.containsKey(a.getStart()))

				annotationsToAddByStartPos.put(a.getStart(), new ArrayList<Annotation>());

			if (!annotationsToAddByEndPos.containsKey(a.getEnd()))

				annotationsToAddByEndPos.put(a.getEnd(), new ArrayList<Annotation>());

			annotationsToAddByStartPos.get(a.getStart()).add(a);

			annotationsToAddByEndPos.get(a.getEnd()).add(a);

		}

		for (int i : annotationsToAddByStartPos.keySet()) {

			List<Annotation> a = annotationsToAddByStartPos.get(i);

			Collections.sort(a, new Comparator<Annotation>() { // reverse sort

																// annotation ->

																// write the

																// smaller in

																// the bigger

						@Override

						public int compare(Annotation arg0, Annotation arg1) {

							return arg1.getEnd() - arg0.getEnd();

						}

					});

		}

		for (int i : annotationsToAddByEndPos.keySet()) {

			List<Annotation> a = annotationsToAddByEndPos.get(i);

			Collections.sort(a, new Comparator<Annotation>() { // reverse sort

																// annotation ->

																// write the

																// smaller in

																// the bigger

						@Override

						public int compare(Annotation arg0, Annotation arg1) {

							return arg1.getStart() - arg0.getStart();

						}

					});

		}

		// sorting token annotations

		this.tokenAnnotations = tokenAnnotations;

		Collections.sort(tokenAnnotations, new Comparator<Annotation>() {

			@Override

			public int compare(Annotation arg0, Annotation arg1) {

				return arg0.getStart() - arg1.getStart();

			}

		});

		if (debug) {

			System.out.println("annotations for " + xmlFile);

			System.out.println(" segment grouped and ordered by start position: " + annotationsToAddByStartPos);

			System.out.println(" segment grouped and ordered by end position: " + annotationsToAddByEndPos);

			System.out.println(" token ordered by start position: " + tokenAnnotations);

		}

	}

	boolean mustChangeAnaValue = false;

	boolean inAna = false;

	protected void processStartElement() throws XMLStreamException, IOException {

		currentStartAnnotations = annotationsToAddByStartPos.get(position_counter);

		currentEndAnnotations = annotationsToAddByEndPos.get(position_counter);

		//System.out.println("A Starts: "+currentStartAnnotations+" "+currentEndAnnotations);

		// if (debug)

		// System.out.println("----- "+localname+"@"+position_counter+" START ANNOT = "+currentStartAnnotations);

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

			super.processStartElement();

			goToEnd("teiHeader"); // skip teiHeader // will be closed in

									// processEndElement()

		} else if ("w".equals(localname)) {

			// System.out.println("W START pos="+position_counter+" annots="+currentStartAnnotations);

			if (currentStartAnnotations != null) {// there are still annotations

													// to write, possible

													// several for a position

				// if (debug)

				// System.out.println("WRITING START at "+position_counter+": "+currentStartAnnotations);

				for (Annotation a : currentStartAnnotations) {

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

						if (debug)

							System.out.println(" force write start annotation " + a);

						writeStartAnnotation(a);

					} else {

						if (debug)

							System.out.println(" no need to write start annotation " + a);

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

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

						// " | currentEndAnnotations : "+currentEndAnnotations);

						if (currentEndAnnotations == null) {

							System.out.println("WARNING ERROR null pointer for end position of annotation " + a);

						} else {

							currentEndAnnotations.remove(a);

						}

					}

				}

			}

			inW = true;

			// get token annotation if any

			currentTokenAnnotations.clear(); // current word annotations to write, may be empty

			Annotation a = null;

			if (tokenAnnotations.size() > 0) {

				a = tokenAnnotations.get(0);

				//System.out.println("for p="+position_counter+" next token annot="+a);

				if (a.getStart() <= position_counter && position_counter <= a.getEnd()) {

					// write the annotation

					currentTokenAnnotations.put(a.getType(), a);

					if (a.getEnd() == position_counter) // its the last word that needs to write this annotation

						tokenAnnotations.remove(0);

				}

			}

			super.processStartElement(); // write the tag

		} else if ("ana".equals(localname)) {

			inAna = true;

			String type = parser.getAttributeValue(null, "type").substring(1);

			if (currentTokenAnnotations.containsKey(type)) {

				Annotation a = currentTokenAnnotations.get(type);

				//System.out.println("Updating token annotation with: " + a);

				String value = a.getValue();

				if ("#del".equals(value))

					value = "";

				if (value == null)

					value = "ERROR";

				try {

					writer.writeStartElement("ana");

					writer.writeAttribute("type", "#" + type);

					writer.writeAttribute("resp", "#" + a.getAnnotator()); // change

																			// resp

					writer.writeCharacters(value);

					mustChangeAnaValue = true;

				} catch (XMLStreamException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				}

				currentTokenAnnotations.remove(type); // annotation updated

			} else {

				super.processStartElement();

			}

		} else if (currentStartAnnotations != null) { // is it an annotations ?

			// System.out.println("A START="+localname);

			boolean toDelete = false;

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

				Annotation a = currentStartAnnotations.get(i);

				// if (debug)

				// System.out.println("=============== Start annot : "+a);

				if (a.getType().equals(localname)) { // force delete, will be

														// written in the "w"

														// case

					int start = Integer.parseInt(parser.getAttributeValue(null, "start"));

					int end = Integer.parseInt(parser.getAttributeValue(null, "end"));

					if (a.getStart() == start && a.getEnd() == end) {

						// updated = true;

						// if (debug)

						// System.out.println(" found existing annotation "+a);

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

							toDelete = true;

							// currentEndAnnotations.remove(a); // MAYBE NOT TO

							// DO THIS HERE ?

							if (debug)

								System.out.println(" force delete start annotation " + a);

						} else { // update existing annotation, no need to store

									// the end of annotation

							writeStartAnnotation(a);

							toDelete = true;

							if (debug)

								System.out.println(" update annotation " + a);

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

																								// NO

																								// CAPITO

																								// YET

																								// !!

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

							// " | currentEndAnnotations : "+currentEndAnnotations);

							if (currentEndAnnotations == null) {

								System.out.println("WARNING ERROR null pointer for end position of annotation " + a);

							} else {

								currentEndAnnotations.remove(a);

							}

						}

						currentStartAnnotations.remove(i);

						i--;

					}

					break; // no need to continue

				} else {

					// System.out.println("------- with same start pos");

					String s_end = parser.getAttributeValue(null, "end");

					String s_start = parser.getAttributeValue(null, "start");

					String s_author = parser.getAttributeValue(null, "author");

					String s_ref = parser.getAttributeValue(null, "ref");

					if (s_start != null && s_end != null && s_author != null && s_ref != null) {

						int end = Integer.parseInt(s_end);

						if (a.getEnd() >= end) { // must write a

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

								if (debug)

									System.out.println(" writing of start annotation " + a);

								writeStartAnnotation(a);

							} else {

								toDelete = true;

								if (debug)

									System.out.println(" no writing of start annotation " + a);

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

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

								// " | currentEndAnnotations : "+currentEndAnnotations);

								if (currentEndAnnotations == null) {

									System.out.println("WARNING ERROR null pointer for end position of annotation " + a);

								} else {

									currentEndAnnotations.remove(a);

								}

							}

							currentStartAnnotations.remove(i);

							i--;

							// break;

						}

					}

				}

			}

			if (!toDelete) { // the structure or annotation was not modified

				super.processStartElement();

			}

		} else {

			// System.out.println("X START="+localname);

			super.processStartElement();

		}

	}

	@Override

	public void processCharacters() throws XMLStreamException {

		//System.out.println("processCharaters inAna="+inAna+" mustChangeAnaValue="+mustChangeAnaValue);

		if (inAna && mustChangeAnaValue) {

			// nothing content is already written

			//System.out.println("skip ana value because we replace it");

		} else {

			super.processCharacters();

		}

	}

	protected void processEndElement() throws XMLStreamException {

		// currentEndAnnotations =

		// annotationsToAddByEndPos.get(position_counter); // annotation to end

		previousEndAnnotations = annotationsToAddByEndPos.get(position_counter - 1); // existing

																						// (or

																						// not)

																						// annotation

																						// that

																						// have

																						// already

																						// been

																						// closed

		// if (debug)

		// System.out.println("----- "+localname+"@"+position_counter+" END ANNOT = "+currentEndAnnotations);

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

			// System.out.println("W END");

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

				try {

					writer.writeStartElement("ana");

					writer.writeAttribute("type", "#" + type);

					writer.writeAttribute("resp", "#" + currentTokenAnnotations.get(type).getAnnotator()); // change

																											// resp

					writer.writeCharacters(currentTokenAnnotations.get(type).getValue());

					writer.writeEndElement();

				} catch (XMLStreamException e) {

					e.printStackTrace();

				}

			}

			super.processEndElement(); // write word then close annotations

			inW = false;

			// force write All known annotation after the word

			if (currentEndAnnotations != null) {// there are still annotations

												// to write, possible several

												// for a position

				// if (debug)

				// System.out.println("WRITING END at "+position_counter+": "+currentEndAnnotations);

				for (Annotation a : currentEndAnnotations) {

					// if (debug)

					// System.out.println("=============== End annot : "+a);

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

						if (debug)

							System.out.println(" force write end annotation " + a);

						writeEndAnnotation(a);

					}/*

					 * else { if (debug)

					 * System.out.println(" no need to write end annotation "

					 * +a); }

					 */

				}

			}

			position_counter++;

		} else if ("ana".equals(localname)) {

			//if (!mustChangeAnaValue)

				super.processEndElement();

			inAna = false;

			mustChangeAnaValue = false;

		} else if (previousEndAnnotations != null) { // force delete annotations

														// previously written in

														// the "w" case

			// System.out.println("previousEndAnnotations !!!!! "+previousEndAnnotations);

			boolean toDelete = false;

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

				Annotation a = previousEndAnnotations.get(i);

				if (a.getType().equals(localname)) { // update the annotation

					// if (debug)

					// System.out.println(" found existing end annotation "+a);

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

														// (!"#del".equals(a.getValue()))

														// {

						toDelete = true;

						if (debug)

							System.out.println(" force delete end annotation " + a);

					}

					previousEndAnnotations.remove(i);

					i--;

					break; // no need to continue

				}

			}

			if (!toDelete) { // the structure or annotation was not modified

				super.processEndElement();

			} else {

				// if (debug)

				// System.out.println("DELETING END at "+position_counter+" localname="+localname+": "+previousEndAnnotations);

			}

		} else {

			// System.out.println("X END="+localname);

			super.processEndElement();

		}

	}

	private void writeStartAnnotation(Annotation a) {

		try {

			writer.writeStartElement("txm:" + a.getType());

			writer.writeAttribute("author", "" + a.getAnnotator());

			writer.writeAttribute("ref", a.getValue());

			writer.writeAttribute("date", BaseParameters.dateformat.format(new Date()));

			writer.writeAttribute("start", Integer.toString(a.getStart()));

			writer.writeAttribute("end", Integer.toString(a.getEnd()));

		} catch (XMLStreamException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	}

	private void writeEndAnnotation(Annotation a) {

		try {

			writer.writeEndElement();

		} catch (XMLStreamException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	}

//////////// TESTS ///////////

	public static ArrayList<Annotation>  testAdding(){

		Annotation a1 = new Annotation("Actr", "Actr100", 15, 16);

		ArrayList<Annotation> annotations = new ArrayList<Annotation>();

		annotations.add(a1);

		return annotations;

	}

	public static ArrayList<Annotation>  testAddingInclusive(){

		Annotation a1 = new Annotation("CoAc", "CoAc2093", 15, 19);

		ArrayList<Annotation> annotations = new ArrayList<Annotation>();

		annotations.add(a1);

		return annotations;

	}

	public static ArrayList<Annotation>  testAddingInclusive2(){

		Annotation a1 = new Annotation("Actr", "Actr100", 15, 16);

		ArrayList<Annotation> annotations = new ArrayList<Annotation>();

		annotations.add(a1);

		return annotations;

	}

	public static ArrayList<Annotation>  testUpdating(){

		Annotation a1 = new Annotation("Actr", "Actr200", 15, 16);

		ArrayList<Annotation> annotations = new ArrayList<Annotation>();

		annotations.add(a1);

		return annotations;

	}

	public static ArrayList<Annotation>  testUpdatingDeleting(){	

		Annotation a1 = new Annotation("Actr", "Actr200", 15, 16);

		Annotation a2 = new Annotation("CoAc", "#del", 15, 19);		

		ArrayList<Annotation> annotations = new ArrayList<Annotation>();

		annotations.add(a1);

		annotations.add(a2);

		return annotations;

	}

	public static ArrayList<Annotation>  testAddDeleting2(){	

		Annotation a1 = new Annotation("Actr", "#del", 15, 16); //DELETE

		Annotation a2 = new Annotation("NaPl", "NaPl14554", 15, 19); //ADD

		ArrayList<Annotation> annotations = new ArrayList<Annotation>();

		annotations.add(a1);

		annotations.add(a2);

		return annotations;

	}

	public static ArrayList<Annotation>  testUpdatingDeletingAdding(){	

		Annotation a1 = new Annotation("Actr", "Actr200", 15, 16); //UPDATE

		Annotation a2 = new Annotation("NaPl", "NaPl14554", 15, 19); //ADD	

		Annotation a3 = new Annotation("CoAc", "#del", 15, 19);	//DELETE	

		ArrayList<Annotation> annotations = new ArrayList<Annotation>();

		annotations.add(a1);

		annotations.add(a2);

		annotations.add(a3);

		return annotations;

	}

	public static ArrayList<Annotation>  testUpdatingDeletingAdding2(){	// NOT WORKING

		Annotation a1 = new Annotation("Actr", "#del", 15, 16); //DELETE

		Annotation a2 = new Annotation("NaPl", "NaPl14554", 15, 19); //ADD  same place as CoAc

		Annotation a3 = new Annotation("CoAc", "CoAc2091", 15, 19); //UPDATE		

		ArrayList<Annotation> annotations = new ArrayList<Annotation>();

		annotations.add(a1);

		annotations.add(a2);

		annotations.add(a3);

		return annotations;

	}

	public static ArrayList<Annotation>  testUpdatingDeletingAdding3(){	// NOT WORKING

		Annotation a1 = new Annotation("Actr", "#del", 15, 16); //DELETE

		Annotation a2 = new Annotation("NaPl", "NaPl14554", 15, 16); //ADD same place as Actr		

		Annotation a3 = new Annotation("CoAc", "CoAc2091", 15, 19); //UPDATE		

		ArrayList<Annotation> annotations = new ArrayList<Annotation>();

		annotations.add(a1);

		annotations.add(a2);

		annotations.add(a3);

		return annotations;

	}

	public static ArrayList<Annotation>  testUpdatingDeletingAdding4(){	

		Annotation a1 = new Annotation("Actr", "#del", 15, 16); //DELETE

		Annotation a2 = new Annotation("NaPl", "NaPl14554", 13, 20); //ADD Outside Actr and CoAc		

		Annotation a3 = new Annotation("CoAc", "CoAc2091", 15, 19); //UPDATE		

		ArrayList<Annotation> annotations = new ArrayList<Annotation>();

		annotations.add(a1);

		annotations.add(a2);

		annotations.add(a3);

		return annotations;

	}

	public static ArrayList<Annotation>  testUpdatingDeletingAdding5(){	

		Annotation a1 = new Annotation("Actr", "#del", 15, 16); //DELETE

		Annotation a2 = new Annotation("NaPl", "NaPl14554", 15, 16); //ADD		

		Annotation a3 = new Annotation("CoAc", "#del", 15, 19); //DELETE		

		ArrayList<Annotation> annotations = new ArrayList<Annotation>();

		annotations.add(a1);

		annotations.add(a2);

		annotations.add(a3);

		return annotations;

	}

	public static ArrayList<Annotation>  testUpdatingDeletingAdding6(){	 

		Annotation a1 = new Annotation("Actr", "#del", 15, 16); //DELETE

		Annotation a2 = new Annotation("NaPl", "NaPl14554", 15, 16); //ADD		

		Annotation a3 = new Annotation("CoAc", "#del", 15, 19); //DELETE		

		Annotation a4 = new Annotation("CoAc", "CoAc1", 15, 18); //DELETE

		ArrayList<Annotation> annotations = new ArrayList<Annotation>();

		annotations.add(a1);

		annotations.add(a2);

		annotations.add(a3);

		annotations.add(a4);

		return annotations;

	}

	public static ArrayList<Annotation>  testUpdatingInclusive(){	

		Annotation a1 = new Annotation("Actr", "Actr200", 15, 16);

		Annotation a2 = new Annotation("CoAc", "CoAc321", 15, 19);		

		ArrayList<Annotation> annotations = new ArrayList<Annotation>();

		annotations.add(a1);

		annotations.add(a2);

		return annotations;

	}

	public static ArrayList<Annotation>  testDeleting(){

		Annotation a1 = new Annotation("Actr", "#del", 15, 16);

		ArrayList<Annotation> annotations = new ArrayList<Annotation>();

		annotations.add(a1);

		return annotations;

	}

	public static ArrayList<Annotation>  testDeletingInclusive(){

		Annotation a1 = new Annotation("Actr", "#del", 15, 16);

		Annotation a2 = new Annotation("CoAc", "#del", 15, 16);		

		ArrayList<Annotation> annotations = new ArrayList<Annotation>();

		annotations.add(a1);

		annotations.add(a2);

		return annotations;

	}

	static int ADD = 1;

	static int UPDATE = 2;

	static int DELETE = 3;

	static int ADD2 = 4;

	static int UPDATE2 = 5;

	static int DELETE2 = 6;

	static int DELETE3 = 7;

	static int DELETE4 = 8;

	static int ADD3 = 9;

	static int UPDATE3 = 10;

	static int UPDATEDELETE = 11;

	static int UPDATEDELETEADD = 12;

	static int UPDATEDELETEADD2 = 13;

	static int UPDATEDELETEADD3 = 14;

	static int UPDATEDELETEADD4 = 15;

	static int UPDATEDELETEADD5 = 16;

	static int UPDATEDELETEADD6 = 17;

	static int ADDDELETE2 = 18;

	public static void main2(String args[]) throws IOException, XMLStreamException {

		File xmlFile = null;

		int corpus_start_position = 10;

		ArrayList<Annotation> annotations = null;

		int test = UPDATEDELETEADD3;//AnnotationWriter.UPDATE;// AnnotationWriter.ADD;

		switch (test) {

		case 1 : 

			//AnnotationWriter.ADD

			xmlFile = new File(System.getProperty("user.home"), "TXM/corpora/TEST/TEST.xml");

			annotations = testAdding(); /// OK

			break;

		case 2 : 

			//AnnotationWriter.UPDATE

			xmlFile = new File(System.getProperty("user.home"), "TXM/corpora/TEST/TEST2.xml");

			annotations = testUpdating(); /// OK

			break;

		case 3 : 

			//AnnotationWriter.DELETE

			xmlFile = new File(System.getProperty("user.home"), "TXM/corpora/TEST/TEST4.xml");

			annotations = testDeleting(); /// OK

			break;

		case 4 : 

			//AnnotationWriter.ADD2

			xmlFile = new File(System.getProperty("user.home"), "TXM/corpora/TEST/TEST3.xml");

			annotations = testAddingInclusive(); /// OK

			break;

		case 5 : 

			//AnnotationWriter.UPDATE2

			xmlFile = new File(System.getProperty("user.home"), "TXM/corpora/TEST/TEST5.xml");

			annotations = testUpdating(); /// OK

			break;

		case 6 : 

			//AnnotationWriter.DELETE2

			xmlFile = new File(System.getProperty("user.home"), "TXM/corpora/TEST/TEST6.xml");

			annotations = testDeleting();

			break;

		case 7 : 

			//AnnotationWriter.DELETE3

			xmlFile = new File(System.getProperty("user.home"), "TXM/corpora/TEST/TEST6.xml");

			annotations = testDeletingInclusive();

			break;

		case 8 : 

			//AnnotationWriter.DELETE4

			xmlFile = new File(System.getProperty("user.home"), "TXM/corpora/TEST/TEST7.xml");

			annotations = testDeletingInclusive();

			break;

		case 9 : 

			//AnnotationWriter.ADD3

			xmlFile = new File(System.getProperty("user.home"), "TXM/corpora/TEST/TEST3bis.xml");

			annotations = testAddingInclusive2(); /// OK

			break;

		case 10 : 

			//AnnotationWriter.UPDATE3

			xmlFile = new File(System.getProperty("user.home"), "TXM/corpora/TEST/TEST5.xml");

			annotations = testUpdatingInclusive(); /// OK

			break;

		case 11 : 

			//AnnotationWriter.UPDATEDELETE

			xmlFile = new File(System.getProperty("user.home"), "TXM/corpora/TEST/TEST5.xml");

			annotations = testUpdatingDeleting(); /// OK

			break;

		case 12 : 

			//AnnotationWriter.UPDATEDELETEADD

			xmlFile = new File(System.getProperty("user.home"), "TXM/corpora/TEST/TEST5.xml");

			annotations = testUpdatingDeletingAdding(); /// NOT OK

			break;

		case 13 : 

			//AnnotationWriter.UPDATEDELETEADD2

			xmlFile = new File(System.getProperty("user.home"), "TXM/corpora/TEST/TEST5.xml");

			annotations = testUpdatingDeletingAdding2(); /// OK

			break;

		case 14 : 

			//AnnotationWriter.UPDATEDELETEADD3

			xmlFile = new File(System.getProperty("user.home"), "TXM/corpora/TEST/TEST5.xml");

			annotations = testUpdatingDeletingAdding3(); /// OK

			break;

		case 15 : 

			//AnnotationWriter.UPDATEDELETEADD4 -- add 1 annotation over the 2 others

			xmlFile = new File(System.getProperty("user.home"), "TXM/corpora/TEST/TEST5.xml");

			annotations = testUpdatingDeletingAdding4(); /// OK

			break;

		case 16 : 

			//AnnotationWriter.UPDATEDELETEADD5 -- delete 2 annotations, add 1

			xmlFile = new File(System.getProperty("user.home"), "TXM/corpora/TEST/TEST5.xml");

			annotations = testUpdatingDeletingAdding5(); /// OK

			break;

		case 17 : 

			//AnnotationWriter.UPDATEDELETEADD6 -- delete 2 annotations, add 2

			xmlFile = new File(System.getProperty("user.home"), "TXM/corpora/TEST/TEST5.xml");

			annotations = testUpdatingDeletingAdding6(); /// NOT OK

			break;

		case 18 : 

			//AnnotationWriter.ADDDELETE -- delete 1, add 1

			xmlFile = new File(System.getProperty("user.home"), "TXM/corpora/TEST/TEST5.xml");

			annotations = testAddDeleting2(); /// OK 

			break;

			//

		default: break;

		}

		// no token annotations

		AnnotationInjector annotationInjector = new AnnotationInjector(xmlFile, annotations, new ArrayList<Annotation>(), corpus_start_position, true);

		File outfile = new File(xmlFile.getParentFile(), "result-"+xmlFile.getName());

		if (annotationInjector.process(outfile)) {

			if (!ValidateXml.test(outfile)) {

				System.out.println("FAIL");

			} else {

				System.out.println("SUCCESS ??");

			}	

		}

	}

	public static void main(String[] args) {

		try {

		File xmlFile = new File("/home/mdecorde/TXM/corpora/TDM80J/txm/TDM80J/tdm80j.xml");

		File outfile = new File("/home/mdecorde/TXM/corpora/TDM80J/txm/TDM80J/tdm80j-annot.xml");

		ArrayList<Annotation> segmentAnnotations = new ArrayList<Annotation>();