MtasXMLParser.java

  1. package mtas.analysis.parser;

  3. import java.io.Reader;
  4. import java.util.Collection;
  5. import java.util.HashMap;
  6. import java.util.HashSet;
  7. import java.util.List;
  8. import java.util.Map;
  9. import java.util.Map.Entry;
  10. import java.util.Set;
  11. import java.util.SortedSet;
  12. import java.util.TreeSet;
  13. import java.util.concurrent.atomic.AtomicInteger;

  15. import javax.xml.namespace.QName;
  16. import javax.xml.stream.XMLInputFactory;
  17. import javax.xml.stream.XMLStreamConstants;
  18. import javax.xml.stream.XMLStreamException;
  19. import javax.xml.stream.XMLStreamReader;

  21. import org.apache.commons.logging.Log;
  22. import org.apache.commons.logging.LogFactory;

  24. import mtas.analysis.token.MtasToken;
  25. import mtas.analysis.token.MtasTokenCollection;
  26. import mtas.analysis.token.MtasTokenIdFactory;
  27. import mtas.analysis.util.MtasConfigException;
  28. import mtas.analysis.util.MtasParserException;
  29. import mtas.analysis.util.MtasConfiguration;

  31. /**
  32.  * The Class MtasXMLParser.
  33.  */
  34. abstract class MtasXMLParser extends MtasBasicParser {

  36.   /** The Constant log. */
  37.   private static final Log log = LogFactory.getLog(MtasXMLParser.class);

  39.   /** The namespace URI. */
  40.   protected String namespaceURI = null;

  42.   /** The namespace URI  id. */
  43.   protected String namespaceURI_id = null;

  45.   /** The root tag. */
  46.   protected String rootTag = null;

  48.   /** The content tag. */
  49.   protected String contentTag = null;

  51.   /** The allow non content. */
  52.   protected boolean allowNonContent = false;

  54.   /** The relation key map. */
  55.   private Map<String, SortedSet<String>> relationKeyMap = new HashMap<>();

  57.   /** The q names. */
  58.   private Map<String, QName> qNames = new HashMap<>();

  60.   /** The relation types. */
  61.   private Map<QName, MtasParserType<MtasParserMapping<?>>> relationTypes = new HashMap<>();

  63.   /** The relation annotation types. */
  64.   private Map<QName, MtasParserType<MtasParserMapping<?>>> relationAnnotationTypes = new HashMap<>();

  66.   /** The ref types. */
  67.   private Map<QName, MtasParserType<MtasParserMapping<?>>> refTypes = new HashMap<>();

  69.   /** The group types. */
  70.   private Map<QName, MtasParserType<MtasParserMapping<?>>> groupTypes = new HashMap<>();

  72.   /** The group annotation types. */
  73.   private Map<QName, MtasParserType<MtasParserMapping<?>>> groupAnnotationTypes = new HashMap<>();

  75.   /** The word types. */
  76.   private Map<QName, MtasParserType<MtasParserMapping<?>>> wordTypes = new HashMap<>();

  78.   /** The word annotation types. */
  79.   private Map<QName, MtasParserType<MtasParserMapping<?>>> wordAnnotationTypes = new HashMap<>();

  81.   /** The variable types. */
  82.   private Map<QName, MtasParserType<MtasParserVariable>> variableTypes = new HashMap<>();

  84.   /** The Constant XML_VARIABLES. */
  85.   private static final String XML_VARIABLES = "variables";

  87.   /** The Constant XML_VARIABLE. */
  88.   private static final String XML_VARIABLE = "variable";

  90.   /** The Constant XML_VARIABLE_NAME. */
  91.   private static final String XML_VARIABLE_NAME = "name";

  93.   /** The Constant XML_VARIABLE_VALUE. */
  94.   private static final String XML_VARIABLE_VALUE = "value";

  96.   /** The Constant XML_REFERENCES. */
  97.   private static final String XML_REFERENCES = "references";

  99.   /** The Constant XML_REFERENCE. */
  100.   private static final String XML_REFERENCE = "reference";

  102.   /** The Constant XML_REFERENCE_NAME. */
  103.   private static final String XML_REFERENCE_NAME = "name";

  105.   /** The Constant XML_REFERENCE_REF. */
  106.   private static final String XML_REFERENCE_REF = "ref";

  108.   /** The Constant XML_MAPPINGS. */
  109.   private static final String XML_MAPPINGS = "mappings";

  111.   /** The Constant XML_MAPPING. */
  112.   private static final String XML_MAPPING = "mapping";

  114.   /** The Constant XML_MAPPING_TYPE. */
  115.   private static final String XML_MAPPING_TYPE = "type";

  117.   /** The Constant XML_MAPPING_NAME. */
  118.   private static final String XML_MAPPING_NAME = "name";

  120.   /**
  121.    * Instantiates a new mtas XML parser.
  122.    *
  123.    * @param config the config
  124.    */
  125.   public MtasXMLParser(MtasConfiguration config) {
  126.     super(config);
  127.     try {
  128.       initParser();
  129.       // System.out.print(printConfig());
  130.     } catch (MtasConfigException e) {
  131.       log.error(e);
  132.     }
  133.   }

  135.   /*
  136.    * (non-Javadoc)
  137.    * 
  138.    * @see mtas.analysis.parser.MtasParser#printConfig()
  139.    */
  140.   @Override
  141.   public String printConfig() {
  142.     StringBuilder text = new StringBuilder();
  143.     text.append("=== CONFIGURATION ===\n");
  144.     text.append("type: " + variableTypes.size() + " x variable\n");
  145.     text.append(printConfigVariableTypes(variableTypes));
  146.     text.append("type: " + groupTypes.size() + " x group\n");
  147.     text.append(printConfigMappingTypes(groupTypes));
  148.     text.append("type: " + groupAnnotationTypes.size() + " x groupAnnotation");
  149.     text.append(printConfigMappingTypes(groupAnnotationTypes));
  150.     text.append("type: " + wordTypes.size() + " x word\n");
  151.     text.append(printConfigMappingTypes(wordTypes));
  152.     text.append("type: " + wordAnnotationTypes.size() + " x wordAnnotation");
  153.     text.append(printConfigMappingTypes(wordAnnotationTypes));
  154.     text.append("type: " + relationTypes.size() + " x relation\n");
  155.     text.append(printConfigMappingTypes(relationTypes));
  156.     text.append(
  157.         "type: " + relationAnnotationTypes.size() + " x relationAnnotation\n");
  158.     text.append(printConfigMappingTypes(relationAnnotationTypes));
  159.     text.append("type: " + refTypes.size() + " x references\n");
  160.     text.append(printConfigMappingTypes(refTypes));
  161.     text.append("=== CONFIGURATION ===\n");
  162.     return text.toString();
  163.   }

  165.   /**
  166.    * Prints the config mapping types.
  167.    *
  168.    * @param types the types
  169.    * @return the string
  170.    */
  171.   private String printConfigMappingTypes(
  172.       Map<QName, MtasParserType<MtasParserMapping<?>>> types) {
  173.     StringBuilder text = new StringBuilder();
  174.     for (Entry<QName, MtasParserType<MtasParserMapping<?>>> entry : types
  175.         .entrySet()) {
  176.       text.append("- " + entry.getKey().getLocalPart() + ": "
  177.           + entry.getValue().items.size() + " mapping(s)\n");
  178.       for (int i = 0; i < entry.getValue().items.size(); i++) {
  179.         text.append("\t" + entry.getValue().items.get(i) + "\n");
  180.       }
  181.     }
  182.     return text.toString();
  183.   }

  185.   /**
  186.    * Prints the config variable types.
  187.    *
  188.    * @param types the types
  189.    * @return the string
  190.    */
  191.   private String printConfigVariableTypes(
  192.       Map<QName, MtasParserType<MtasParserVariable>> types) {
  193.     StringBuilder text = new StringBuilder();
  194.     for (Entry<QName, MtasParserType<MtasParserVariable>> entry : types
  195.         .entrySet()) {
  196.       text.append("- " + entry.getKey().getLocalPart() + ": "
  197.           + entry.getValue().items.size() + " variables(s)\n");
  198.       for (int i = 0; i < entry.getValue().items.size(); i++) {
  199.         text.append("\t" + entry.getValue().items.get(i) + "\n");
  200.       }
  201.     }
  202.     return text.toString();
  203.   }

  205.   /*
  206.    * (non-Javadoc)
  207.    * 
  208.    * @see mtas.analysis.parser.MtasParser#initParser()
  209.    */
  210.   @Override
  211.   protected void initParser() throws MtasConfigException {
  212.     super.initParser();
  213.     if (config != null) {
  214.       // find namespaceURI
  215.       for (int i = 0; i < config.children.size(); i++) {
  216.         MtasConfiguration current = config.children.get(i);
  217.         if (current.name.equals("namespaceURI")) {
  218.           namespaceURI = current.attributes.get("value");
  219.         }
  220.       }
  221.       // loop again
  222.       for (int i = 0; i < config.children.size(); i++) {
  223.         MtasConfiguration current = config.children.get(i);
  224.         if (current.name.equals(XML_VARIABLES)) {
  225.           for (int j = 0; j < current.children.size(); j++) {
  226.             if (current.children.get(j).name.equals(XML_VARIABLE)) {
  227.               MtasConfiguration variable = current.children.get(j);
  228.               String nameVariable = variable.attributes.get(XML_VARIABLE_NAME);
  229.               String valueVariable = variable.attributes
  230.                   .get(XML_VARIABLE_VALUE);
  231.               if ((nameVariable != null) && (valueVariable != null)) {
  232.                 MtasParserVariable v = new MtasParserVariable(nameVariable,
  233.                     valueVariable);
  234.                 v.processConfig(variable);
  235.                 QName qn = getQName(nameVariable);
  236.                 if (variableTypes.containsKey(qn)) {
  237.                   variableTypes.get(qn).addItem(v);
  238.                 } else {
  239.                   MtasParserType<MtasParserVariable> t = new MtasParserType<>(
  240.                       nameVariable, valueVariable, false);
  241.                   t.addItem(v);
  242.                   variableTypes.put(qn, t);
  243.                 }
  244.               }
  245.             }
  246.           }
  247.         } else if (current.name.equals(XML_REFERENCES)) {
  248.           for (int j = 0; j < current.children.size(); j++) {
  249.             if (current.children.get(j).name.equals(XML_REFERENCE)) {
  250.               MtasConfiguration reference = current.children.get(j);
  251.               String name = reference.attributes.get(XML_REFERENCE_NAME);
  252.               String ref = reference.attributes.get(XML_REFERENCE_REF);
  253.               if ((name != null) && (ref != null)) {
  254.                 MtasParserType<MtasParserMapping<?>> t = new MtasParserType<>(
  255.                     MAPPING_TYPE_REF, name, false, ref);
  256.                 refTypes.put(getQName(t.getName()), t);
  257.               }
  258.             }
  259.           }
  260.         } else if (current.name.equals(XML_MAPPINGS)) {
  261.           for (int j = 0; j < current.children.size(); j++) {
  262.             if (current.children.get(j).name.equals(XML_MAPPING)) {
  263.               MtasConfiguration mapping = current.children.get(j);
  264.               String typeMapping = mapping.attributes.get(XML_MAPPING_TYPE);
  265.               String nameMapping = mapping.attributes.get(XML_MAPPING_NAME);
  266.               if ((typeMapping != null) && (nameMapping != null)) {
  267.                 if (typeMapping.equals(MAPPING_TYPE_RELATION)) {
  268.                   MtasXMLParserMappingRelation m = new MtasXMLParserMappingRelation();
  269.                   m.processConfig(mapping);
  270.                   QName qn = getQName(nameMapping);
  271.                   if (relationTypes.containsKey(qn)) {
  272.                     relationTypes.get(qn).addItem(m);
  273.                   } else {
  274.                     MtasParserType<MtasParserMapping<?>> t = new MtasParserType<>(
  275.                         typeMapping, nameMapping, false);
  276.                     t.addItem(m);
  277.                     relationTypes.put(qn, t);
  278.                   }
  279.                 } else if (typeMapping
  280.                     .equals(MAPPING_TYPE_RELATION_ANNOTATION)) {
  281.                   MtasXMLParserMappingRelationAnnotation m = new MtasXMLParserMappingRelationAnnotation();
  282.                   m.processConfig(mapping);
  283.                   QName qn = getQName(nameMapping);
  284.                   if (relationAnnotationTypes.containsKey(qn)) {
  285.                     relationAnnotationTypes.get(qn).addItem(m);
  286.                   } else {
  287.                     MtasParserType<MtasParserMapping<?>> t = new MtasParserType<>(
  288.                         typeMapping, nameMapping, false);
  289.                     t.addItem(m);
  290.                     relationAnnotationTypes.put(qn, t);
  291.                   }
  292.                 } else if (typeMapping.equals(MAPPING_TYPE_WORD)) {
  293.                   MtasXMLParserMappingWord m = new MtasXMLParserMappingWord();
  294.                   m.processConfig(mapping);
  295.                   QName qn = getQName(nameMapping);
  296.                   if (wordTypes.containsKey(qn)) {
  297.                     wordTypes.get(qn).addItem(m);
  298.                   } else {
  299.                     MtasParserType<MtasParserMapping<?>> t = new MtasParserType<>(
  300.                         typeMapping, nameMapping, false);
  301.                     t.addItem(m);
  302.                     wordTypes.put(qn, t);
  303.                   }
  304.                 } else if (typeMapping.equals(MAPPING_TYPE_WORD_ANNOTATION)) {
  305.                   MtasXMLParserMappingWordAnnotation m = new MtasXMLParserMappingWordAnnotation();
  306.                   m.processConfig(mapping);
  307.                   QName qn = getQName(nameMapping);
  308.                   if (wordAnnotationTypes.containsKey(qn)) {
  309.                     wordAnnotationTypes.get(qn).addItem(m);
  310.                   } else {
  311.                     MtasParserType<MtasParserMapping<?>> t = new MtasParserType<>(
  312.                         typeMapping, nameMapping, false);
  313.                     t.addItem(m);
  314.                     wordAnnotationTypes.put(qn, t);
  315.                   }
  316.                 } else if (typeMapping.equals(MAPPING_TYPE_GROUP)) {
  317.                   MtasXMLParserMappingGroup m = new MtasXMLParserMappingGroup();
  318.                   m.processConfig(mapping);
  319.                   QName qn = getQName(nameMapping);
  320.                   if (groupTypes.containsKey(qn)) {
  321.                     groupTypes.get(qn).addItem(m);
  322.                   } else {
  323.                     MtasParserType<MtasParserMapping<?>> t = new MtasParserType<>(
  324.                         typeMapping, nameMapping, false);
  325.                     t.addItem(m);
  326.                     groupTypes.put(qn, t);
  327.                   }
  328.                 } else if (typeMapping.equals(MAPPING_TYPE_GROUP_ANNOTATION)) {
  329.                   MtasXMLParserMappingGroupAnnotation m = new MtasXMLParserMappingGroupAnnotation();
  330.                   m.processConfig(mapping);
  331.                   QName qn = getQName(nameMapping);
  332.                   if (groupAnnotationTypes.containsKey(qn)) {
  333.                     groupAnnotationTypes.get(qn).addItem(m);
  334.                   } else {
  335.                     MtasParserType<MtasParserMapping<?>> t = new MtasParserType<>(
  336.                         typeMapping, nameMapping, false);
  337.                     t.addItem(m);
  338.                     groupAnnotationTypes.put(qn, t);
  339.                   }
  340.                 } else {
  341.                   throw new MtasConfigException(
  342.                       "unknown mapping type " + typeMapping);
  343.                 }
  344.               }
  345.             }
  346.           }
  347.         }
  348.       }
  349.     }
  350.   }

  352.   /*
  353.    * (non-Javadoc)
  354.    * 
  355.    * @see mtas.analysis.parser.MtasParser#createTokenCollection(java.io.Reader)
  356.    */
  357.   @Override
  358.   public MtasTokenCollection createTokenCollection(Reader reader)
  359.       throws MtasParserException, MtasConfigException {
  360.     Boolean hasRoot = rootTag == null ? true : false;
  361.     Boolean parsingContent = contentTag == null ? true : false;
  362.     String textContent = null;
  363.     Integer unknownAncestors = 0;
  364.     Integer lastOffset = 0;

  366.     AtomicInteger position = new AtomicInteger(0);
  367.     Map<String, Set<Integer>> idPositions = new HashMap<>();
  368.     Map<String, Integer[]> idOffsets = new HashMap<>();

  370.     Map<String, Map<Integer, Set<String>>> updateList = createUpdateList();
  371.     Map<String, List<MtasParserObject>> currentList = createCurrentList();
  372.     Map<String, Map<String, String>> variables = createVariables();

  374.     tokenCollection = new MtasTokenCollection();
  375.     MtasTokenIdFactory mtasTokenIdFactory = new MtasTokenIdFactory();
  376.     XMLInputFactory factory = XMLInputFactory.newInstance();
  377.     try {      
  378.       XMLStreamReader streamReader = factory.createXMLStreamReader(reader);
  379.       QName qname;
  380.       try {
  381.         int event = streamReader.getEventType();
  382.         MtasParserType<?> currentType;
  383.         MtasParserType<?> tmpCurrentType;
  384.         MtasParserType<?> tmpVariableType;
  385.         MtasParserObject currentObject = null;
  386.         MtasParserObject variableObject = null;
  387.         while (true) {
  388.           switch (event) {
  389.           case XMLStreamConstants.START_DOCUMENT:
  390.             log.debug("start of document");
  391.             String encodingScheme = streamReader.getCharacterEncodingScheme();
  392.             if (encodingScheme == null) {
  393.               //ignore for now
  394.               log.info("No encodingScheme found, assume utf-8");
  395.               //throw new MtasParserException("No encodingScheme found");              
  396.             } else if (!encodingScheme.equalsIgnoreCase("utf-8")) {
  397.               throw new MtasParserException(
  398.                   "XML not UTF-8 encoded but '" + encodingScheme + "'");
  399.             }
  400.             break;
  401.           case XMLStreamConstants.END_DOCUMENT:
  402.             log.debug("end of document");
  403.             break;
  404.           case XMLStreamConstants.SPACE:
  405.             // set offset (end of start-element)
  406.             lastOffset = streamReader.getLocation().getCharacterOffset();
  407.             break;
  408.           case XMLStreamConstants.START_ELEMENT:
  409.             // get data
  410.             qname = streamReader.getName();
  411.             // check for rootTag
  412.             if (!hasRoot) {
  413.               if (qname.equals(getQName(rootTag))) {
  414.                 hasRoot = true;
  415.               } else {
  416.                 throw new MtasParserException("No " + rootTag);
  417.               }
  418.               // parse content
  419.             } else {
  420.               if ((tmpVariableType = variableTypes.get(qname)) != null) {
  421.                 variableObject = new MtasParserObject(tmpVariableType);
  422.                 collectAttributes(variableObject, streamReader);
  423.                 computeVariablesFromObject(variableObject, currentList,
  424.                     variables);
  425.               }
  426.               if (parsingContent) {
  427.                 // check for relation : not within word, not within
  428.                 // groupAnnotation
  429.                 if ((currentList.get(MAPPING_TYPE_WORD).isEmpty())
  430.                     && (currentList.get(MAPPING_TYPE_GROUP_ANNOTATION)
  431.                         .isEmpty())
  432.                     && (tmpCurrentType = relationTypes.get(qname)) != null) {
  433.                   currentObject = new MtasParserObject(tmpCurrentType);
  434.                   collectAttributes(currentObject, streamReader);
  435.                   currentObject.setUnknownAncestorNumber(unknownAncestors);
  436.                   currentObject.setRealOffsetStart(lastOffset);
  437.                   if (!prevalidateObject(currentObject, currentList)) {
  438.                     unknownAncestors++;
  439.                   } else {
  440.                     currentType = tmpCurrentType;
  441.                     currentList.get(MAPPING_TYPE_RELATION).add(currentObject);
  442.                     unknownAncestors = 0;
  443.                   }
  444.                   // check for relation annotation: not within word, but within
  445.                   // relation
  446.                 } else if ((currentList.get(MAPPING_TYPE_WORD).isEmpty())
  447.                     && (!currentList.get(MAPPING_TYPE_RELATION).isEmpty())
  448.                     && (tmpCurrentType = relationAnnotationTypes
  449.                         .get(qname)) != null) {
  450.                   currentObject = new MtasParserObject(tmpCurrentType);
  451.                   collectAttributes(currentObject, streamReader);
  452.                   currentObject.setUnknownAncestorNumber(unknownAncestors);
  453.                   currentObject.setRealOffsetStart(lastOffset);
  454.                   if (!prevalidateObject(currentObject, currentList)) {
  455.                     unknownAncestors++;
  456.                   } else {
  457.                     currentType = tmpCurrentType;
  458.                     currentList.get(MAPPING_TYPE_RELATION_ANNOTATION)
  459.                         .add(currentObject);
  460.                     unknownAncestors = 0;
  461.                   }
  462.                   // check for group: not within word, not within relation, not
  463.                   // within groupAnnotation
  464.                 } else if ((currentList.get(MAPPING_TYPE_WORD).isEmpty())
  465.                     && (currentList.get(MAPPING_TYPE_RELATION).isEmpty())
  466.                     && (currentList.get(MAPPING_TYPE_GROUP_ANNOTATION)
  467.                         .isEmpty())
  468.                     && (tmpCurrentType = groupTypes.get(qname)) != null) {
  469.                   currentObject = new MtasParserObject(tmpCurrentType);
  470.                   collectAttributes(currentObject, streamReader);
  471.                   currentObject.setUnknownAncestorNumber(unknownAncestors);
  472.                   currentObject.setRealOffsetStart(lastOffset);
  473.                   if (!prevalidateObject(currentObject, currentList)) {
  474.                     unknownAncestors++;
  475.                   } else {
  476.                     currentType = tmpCurrentType;
  477.                     currentList.get(MAPPING_TYPE_GROUP).add(currentObject);
  478.                     unknownAncestors = 0;
  479.                   }
  480.                   // check for group annotation: not within word, not within
  481.                   // relation, but within group
  482.                 } else if ((currentList.get(MAPPING_TYPE_WORD).isEmpty())
  483.                     && (currentList.get(MAPPING_TYPE_RELATION).isEmpty())
  484.                     && (!currentList.get(MAPPING_TYPE_GROUP).isEmpty())
  485.                     && (tmpCurrentType = groupAnnotationTypes
  486.                         .get(qname)) != null) {
  487.                   currentObject = new MtasParserObject(tmpCurrentType);
  488.                   collectAttributes(currentObject, streamReader);
  489.                   currentObject.setUnknownAncestorNumber(unknownAncestors);
  490.                   currentObject.setRealOffsetStart(lastOffset);
  491.                   if (!prevalidateObject(currentObject, currentList)) {
  492.                     unknownAncestors++;
  493.                   } else {
  494.                     currentType = tmpCurrentType;
  495.                     currentList.get(MAPPING_TYPE_GROUP_ANNOTATION)
  496.                         .add(currentObject);
  497.                     unknownAncestors = 0;
  498.                   }
  499.                   // check for word: not within relation, not within
  500.                   // groupAnnotation, not within word, not within wordAnnotation
  501.                 } else if ((currentList.get(MAPPING_TYPE_RELATION).isEmpty())
  502.                     && (currentList.get(MAPPING_TYPE_GROUP_ANNOTATION)
  503.                         .isEmpty())
  504.                     && (currentList.get(MAPPING_TYPE_WORD).isEmpty())
  505.                     && (currentList.get(MAPPING_TYPE_WORD_ANNOTATION).isEmpty())
  506.                     && (tmpCurrentType = wordTypes.get(qname)) != null) {
  507.                   currentObject = new MtasParserObject(tmpCurrentType);
  508.                   collectAttributes(currentObject, streamReader);
  509.                   currentObject.setUnknownAncestorNumber(unknownAncestors);
  510.                   currentObject.setOffsetStart(lastOffset);
  511.                   currentObject.setRealOffsetStart(lastOffset);
  512.                   if (!prevalidateObject(currentObject, currentList)) {
  513.                     unknownAncestors++;
  514.                   } else {
  515.                     currentType = tmpCurrentType;
  516.                     currentObject.addPosition(position.getAndIncrement());
  517.                     currentList.get(MAPPING_TYPE_WORD).add(currentObject);
  518.                     unknownAncestors = 0;
  519.                   }
  520.                   // check for word annotation: not within relation, not within
  521.                   // groupAnnotation, but within word
  522.                 } else if ((currentList.get(MAPPING_TYPE_RELATION).isEmpty())
  523.                     && (currentList.get(MAPPING_TYPE_GROUP_ANNOTATION)
  524.                         .isEmpty())
  525.                     && (!currentList.get(MAPPING_TYPE_WORD).isEmpty())
  526.                     && (tmpCurrentType = wordAnnotationTypes
  527.                         .get(qname)) != null) {
  528.                   currentObject = new MtasParserObject(tmpCurrentType);
  529.                   collectAttributes(currentObject, streamReader);
  530.                   currentObject.addPositions(currentList.get(MAPPING_TYPE_WORD)
  531.                       .get((currentList.get(MAPPING_TYPE_WORD).size() - 1))
  532.                       .getPositions());
  533.                   currentObject.setUnknownAncestorNumber(unknownAncestors);
  534.                   currentObject.setRealOffsetStart(lastOffset);
  535.                   if (!prevalidateObject(currentObject, currentList)) {
  536.                     unknownAncestors++;
  537.                   } else {
  538.                     currentType = tmpCurrentType;
  539.                     currentList.get(MAPPING_TYPE_WORD_ANNOTATION)
  540.                         .add(currentObject);
  541.                     unknownAncestors = 0;
  542.                   }
  543.                   // check for references: within relation
  544.                 } else if (!currentList.get(MAPPING_TYPE_RELATION).isEmpty()
  545.                     && (tmpCurrentType = refTypes.get(qname)) != null) {
  546.                   currentObject = new MtasParserObject(tmpCurrentType);
  547.                   collectAttributes(currentObject, streamReader);
  548.                   currentObject.setUnknownAncestorNumber(unknownAncestors);
  549.                   currentObject.setRealOffsetStart(lastOffset);
  550.                   if (!prevalidateObject(currentObject, currentList)) {
  551.                     unknownAncestors++;
  552.                   } else {
  553.                     currentType = tmpCurrentType;
  554.                     currentList.get(MAPPING_TYPE_REF).add(currentObject);
  555.                     unknownAncestors = 0;
  556.                     // add reference to ancestor relations
  557.                     for (MtasParserObject currentRelation : currentList
  558.                         .get(MAPPING_TYPE_RELATION)) {
  559.                       currentRelation.addRefId(currentObject
  560.                           .getAttribute(currentType.getRefAttributeName()));
  561.                       // register mapping for relation (for recursive relations)
  562.                       SortedSet<String> keyMapList;
  563.                       if (currentRelation.getId() != null) {
  564.                         if (relationKeyMap
  565.                             .containsKey(currentRelation.getId())) {
  566.                           keyMapList = relationKeyMap
  567.                               .get(currentRelation.getId());
  568.                         } else {
  569.                           keyMapList = new TreeSet<>();
  570.                           relationKeyMap.put(currentRelation.getId(),
  571.                               keyMapList);
  572.                         }
  573.                         keyMapList.add(currentObject
  574.                             .getAttribute(currentType.getRefAttributeName()));
  575.                       }
  576.                     }
  577.                   }
  578.                 } else {
  579.                   unknownAncestors++;
  580.                 }
  581.                 // check for start content
  582.               } else if (qname.equals(getQName(contentTag))) {
  583.                 parsingContent = true;
  584.                 // unexpected
  585.               } else if (!allowNonContent) {
  586.                 throw new MtasParserException(
  587.                     "Unexpected " + qname.getLocalPart() + " in document");
  588.               }
  589.             }
  590.             // set offset (end of start-element)
  591.             lastOffset = streamReader.getLocation().getCharacterOffset();
  592.             break;
  593.           case XMLStreamConstants.END_ELEMENT:
  594.             // set offset (end of end-element)
  595.             lastOffset = streamReader.getLocation().getCharacterOffset();
  596.             // get data
  597.             qname = streamReader.getName();
  598.             // parse content
  599.             if (parsingContent) {
  600.               if (unknownAncestors > 0) {
  601.                 unknownAncestors--;
  602.                 // check for reference: because otherwise currentList should
  603.                 // contain no references
  604.               } else if (!currentList.get(MAPPING_TYPE_REF).isEmpty()) {
  605.                 if ((currentType = refTypes.get(qname)) != null) {
  606.                   currentObject = currentList.get(MAPPING_TYPE_REF)
  607.                       .remove(currentList.get(MAPPING_TYPE_REF).size() - 1);
  608.                   assert currentObject.getType()
  609.                       .equals(currentType) : "object expected to be "
  610.                           + currentObject.getType().getName() + ", not "
  611.                           + currentType.getName();
  612.                   assert unknownAncestors == 0 : "error in administration "
  613.                       + currentObject.getType().getName();
  614.                   // ignore text and realOffset: not relevant
  615.                   idPositions.put(currentObject.getId(),
  616.                       currentObject.getPositions());
  617.                   idOffsets.put(currentObject.getId(),
  618.                       currentObject.getOffset());
  619.                   currentObject.updateMappings(idPositions, idOffsets);
  620.                   unknownAncestors = currentObject.getUnknownAncestorNumber();
  621.                   computeMappingsFromObject(mtasTokenIdFactory, currentObject,
  622.                       currentList, updateList);
  623.                 } else {
  624.                   // this shouldn't happen
  625.                 }
  626.                 // check for wordAnnotation: because otherwise currentList
  627.                 // should contain no wordAnnotations
  628.               } else if (!currentList.get(MAPPING_TYPE_WORD_ANNOTATION)
  629.                   .isEmpty()) {
  630.                 if ((currentType = wordAnnotationTypes.get(qname)) != null) {
  631.                   currentObject = currentList.get(MAPPING_TYPE_WORD_ANNOTATION)
  632.                       .remove(
  633.                           currentList.get(MAPPING_TYPE_WORD_ANNOTATION).size()
  634.                               - 1);
  635.                   assert currentObject.getType()
  636.                       .equals(currentType) : "object expected to be "
  637.                           + currentObject.getType().getName() + ", not "
  638.                           + currentType.getName();
  639.                   assert unknownAncestors == 0 : "error in administration "
  640.                       + currentObject.getType().getName();
  641.                   currentObject.setRealOffsetEnd(lastOffset);
  642.                   idPositions.put(currentObject.getId(),
  643.                       currentObject.getPositions());
  644.                   idOffsets.put(currentObject.getId(),
  645.                       currentObject.getOffset());
  646.                   // offset always null, so update later with word (should be
  647.                   // possible)
  648.                   if ((currentObject.getId() != null)
  649.                       && (!currentList.get(MAPPING_TYPE_WORD).isEmpty())) {
  650.                     currentList.get(MAPPING_TYPE_WORD)
  651.                         .get((currentList.get(MAPPING_TYPE_WORD).size() - 1))
  652.                         .addUpdateableIdWithOffset(currentObject.getId());
  653.                   }
  654.                   currentObject.updateMappings(idPositions, idOffsets);
  655.                   unknownAncestors = currentObject.getUnknownAncestorNumber();
  656.                   computeMappingsFromObject(mtasTokenIdFactory, currentObject,
  657.                       currentList, updateList);
  658.                 } else {
  659.                   // this shouldn't happen
  660.                 }
  661.                 // check for word: because otherwise currentList should contain
  662.                 // no words
  663.               } else if (!currentList.get(MAPPING_TYPE_WORD).isEmpty()) {
  664.                 if ((currentType = wordTypes.get(qname)) != null) {
  665.                   currentObject = currentList.get(MAPPING_TYPE_WORD)
  666.                       .remove(currentList.get(MAPPING_TYPE_WORD).size() - 1);
  667.                   assert currentObject.getType()
  668.                       .equals(currentType) : "object expected to be "
  669.                           + currentObject.getType().getName() + ", not "
  670.                           + currentType.getName();
  671.                   assert unknownAncestors == 0 : "error in administration "
  672.                       + currentObject.getType().getName();
  673.                   currentObject.setOffsetEnd(lastOffset);
  674.                   currentObject.setRealOffsetEnd(lastOffset);
  675.                   // update ancestor groups with position and offset
  676.                   for (MtasParserObject currentGroup : currentList
  677.                       .get(MAPPING_TYPE_GROUP)) {
  678.                     currentGroup.addPositions(currentObject.getPositions());
  679.                     currentGroup.addOffsetStart(currentObject.getOffsetStart());
  680.                     currentGroup.addOffsetEnd(currentObject.getOffsetEnd());
  681.                   }
  682.                   idPositions.put(currentObject.getId(),
  683.                       currentObject.getPositions());
  684.                   idOffsets.put(currentObject.getId(),
  685.                       currentObject.getOffset());
  686.                   currentObject.updateMappings(idPositions, idOffsets);
  687.                   unknownAncestors = currentObject.getUnknownAncestorNumber();
  688.                   computeMappingsFromObject(mtasTokenIdFactory, currentObject,
  689.                       currentList, updateList);
  690.                 } else {
  691.                   // this shouldn't happen
  692.                 }
  693.                 // check for group annotation: because otherwise currentList
  694.                 // should contain no groupAnnotations
  695.               } else if (!currentList.get(MAPPING_TYPE_GROUP_ANNOTATION)
  696.                   .isEmpty()) {
  697.                 if ((currentType = groupAnnotationTypes.get(qname)) != null) {
  698.                   currentObject = currentList.get(MAPPING_TYPE_GROUP_ANNOTATION)
  699.                       .remove(
  700.                           currentList.get(MAPPING_TYPE_GROUP_ANNOTATION).size()
  701.                               - 1);
  702.                   assert currentObject.getType()
  703.                       .equals(currentType) : "object expected to be "
  704.                           + currentObject.getType().getName() + ", not "
  705.                           + currentType.getName();
  706.                   assert unknownAncestors == 0 : "error in administration "
  707.                       + currentObject.getType().getName();
  708.                   currentObject.setRealOffsetEnd(lastOffset);
  709.                   idPositions.put(currentObject.getId(),
  710.                       currentObject.getPositions());
  711.                   idOffsets.put(currentObject.getId(),
  712.                       currentObject.getOffset());
  713.                   currentObject.updateMappings(idPositions, idOffsets);
  714.                   unknownAncestors = currentObject.getUnknownAncestorNumber();
  715.                   computeMappingsFromObject(mtasTokenIdFactory, currentObject,
  716.                       currentList, updateList);
  717.                 } else {
  718.                   // this shouldn't happen
  719.                 }
  720.                 // check for relation annotation
  721.               } else if (!currentList.get(MAPPING_TYPE_RELATION_ANNOTATION)
  722.                   .isEmpty()) {
  723.                 if ((currentType = relationAnnotationTypes
  724.                     .get(qname)) != null) {
  725.                   currentObject = currentList
  726.                       .get(MAPPING_TYPE_RELATION_ANNOTATION).remove(currentList
  727.                           .get(MAPPING_TYPE_RELATION_ANNOTATION).size() - 1);
  728.                   assert currentObject.getType()
  729.                       .equals(currentType) : "object expected to be "
  730.                           + currentObject.getType().getName() + ", not "
  731.                           + currentType.getName();
  732.                   assert unknownAncestors == 0 : "error in administration "
  733.                       + currentObject.getType().getName();
  734.                   currentObject.setRealOffsetEnd(lastOffset);
  735.                   idPositions.put(currentObject.getId(),
  736.                       currentObject.getPositions());
  737.                   idOffsets.put(currentObject.getId(),
  738.                       currentObject.getOffset());
  739.                   currentObject.updateMappings(idPositions, idOffsets);
  740.                   unknownAncestors = currentObject.getUnknownAncestorNumber();
  741.                   computeMappingsFromObject(mtasTokenIdFactory, currentObject,
  742.                       currentList, updateList);
  743.                 } else {
  744.                   // this shouldn't happen
  745.                 }
  746.                 // check for relation
  747.               } else if (!currentList.get(MAPPING_TYPE_RELATION).isEmpty()) {
  748.                 if ((currentType = relationTypes.get(qname)) != null) {
  749.                   currentObject = currentList.get(MAPPING_TYPE_RELATION).remove(
  750.                       currentList.get(MAPPING_TYPE_RELATION).size() - 1);
  751.                   assert currentObject.getType()
  752.                       .equals(currentType) : "object expected to be "
  753.                           + currentObject.getType().getName() + ", not "
  754.                           + currentType.getName();
  755.                   assert unknownAncestors == 0 : "error in administration "
  756.                       + currentObject.getType().getName();
  757.                   // ignore text: should not occur
  758.                   currentObject.setRealOffsetEnd(lastOffset);
  759.                   idPositions.put(currentObject.getId(),
  760.                       currentObject.getPositions());
  761.                   idOffsets.put(currentObject.getId(),
  762.                       currentObject.getOffset());
  763.                   currentObject.updateMappings(idPositions, idOffsets);
  764.                   unknownAncestors = currentObject.getUnknownAncestorNumber();
  765.                   computeMappingsFromObject(mtasTokenIdFactory, currentObject,
  766.                       currentList, updateList);
  767.                 } else {
  768.                   // this shouldn't happen
  769.                 }
  770.                 // check for group
  771.               } else if (!currentList.get(MAPPING_TYPE_GROUP).isEmpty()) {
  772.                 if ((currentType = groupTypes.get(qname)) != null) {
  773.                   currentObject = currentList.get(MAPPING_TYPE_GROUP)
  774.                       .remove(currentList.get(MAPPING_TYPE_GROUP).size() - 1);
  775.                   assert currentObject.getType()
  776.                       .equals(currentType) : "object expected to be "
  777.                           + currentObject.getType().getName() + ", not "
  778.                           + currentType.getName();
  779.                   assert unknownAncestors == 0 : "error in administration "
  780.                       + currentObject.getType().getName();
  781.                   // ignore text: should not occur
  782.                   currentObject.setRealOffsetEnd(lastOffset);
  783.                   idPositions.put(currentObject.getId(),
  784.                       currentObject.getPositions());
  785.                   idOffsets.put(currentObject.getId(),
  786.                       currentObject.getOffset());
  787.                   currentObject.updateMappings(idPositions, idOffsets);
  788.                   unknownAncestors = currentObject.getUnknownAncestorNumber();
  789.                   computeMappingsFromObject(mtasTokenIdFactory, currentObject,
  790.                       currentList, updateList);
  791.                 } else {
  792.                   unknownAncestors--;
  793.                 }
  794.               } else if (qname.equals(getQName("text"))) {
  795.                 parsingContent = false;
  796.                 assert unknownAncestors == 0 : "error in administration unknownAncestors";
  797.                 assert currentList.get(MAPPING_TYPE_REF)
  798.                     .isEmpty() : "error in administration references";
  799.                 assert currentList.get(MAPPING_TYPE_GROUP)
  800.                     .isEmpty() : "error in administration groups";
  801.                 assert currentList.get(MAPPING_TYPE_GROUP_ANNOTATION)
  802.                     .isEmpty() : "error in administration groupAnnotations";
  803.                 assert currentList.get(MAPPING_TYPE_WORD)
  804.                     .isEmpty() : "error in administration words";
  805.                 assert currentList.get(MAPPING_TYPE_WORD_ANNOTATION)
  806.                     .isEmpty() : "error in administration wordAnnotations";
  807.                 assert currentList.get(MAPPING_TYPE_RELATION)
  808.                     .isEmpty() : "error in administration relations";
  809.                 assert currentList.get(MAPPING_TYPE_RELATION_ANNOTATION)
  810.                     .isEmpty() : "error in administration relationAnnotations";
  811.               }
  812.             }
  813.             // forget text
  814.             textContent = null;
  815.             break;
  816.           case XMLStreamConstants.CHARACTERS:
  817.             // set offset (end of start-element)
  818.             lastOffset = streamReader.getLocation().getCharacterOffset();
  819.             // check for text
  820.             if (streamReader.hasText()) {
  821.               textContent = streamReader.getText();
  822.             }
  823.             if (currentObject != null && unknownAncestors.equals(0)) {
  824.               currentObject.addText(textContent);
  825.             }
  826.             break;
  827.           default:
  828.             break;
  829.           }
  830.           if (!streamReader.hasNext()) {
  831.             break;
  832.           }
  833.           event = streamReader.next();
  834.         }
  835.       } finally {
  836.         streamReader.close();
  837.       }
  838.       // final checks
  839.       assert unknownAncestors == 0 : "error in administration unknownAncestors";
  840.       assert hasRoot : "no " + rootTag;
  841.     } catch (XMLStreamException e) {
  842.       log.debug(e);      
  843.       throw new MtasParserException("No valid XML: " + e.getMessage());
  844.     }

  846.     // update tokens with variable
  847.     for (Entry<Integer, Set<String>> updateItem : updateList
  848.         .get(UPDATE_TYPE_VARIABLE).entrySet()) {
  849.       MtasToken token = tokenCollection.get(updateItem.getKey());
  850.       String encodedPrefix = token.getPrefix();
  851.       String encodedPostfix = token.getPostfix();
  852.       token.setValue(decodeAndUpdateWithVariables(encodedPrefix, encodedPostfix,
  853.           variables));
  854.     }
  855.     // update tokens with offset
  856.     for (Entry<Integer, Set<String>> updateItem : updateList
  857.         .get(UPDATE_TYPE_OFFSET).entrySet()) {
  858.       Set<String> refIdList = new HashSet<>();
  859.       for (String refId : updateItem.getValue()) {
  860.         if (idPositions.containsKey(refId)) {
  861.           refIdList.add(refId);
  862.         }
  863.         if (relationKeyMap.containsKey(refId)) {
  864.           refIdList.addAll(recursiveCollect(refId, relationKeyMap, 10));
  865.         }
  866.       }
  867.       for (String refId : refIdList) {
  868.         Integer[] refOffset = idOffsets.get(refId);
  869.         Integer tokenId = updateItem.getKey();
  870.         if (tokenId != null && refOffset != null) {
  871.           MtasToken token = tokenCollection.get(tokenId);
  872.           token.addOffset(refOffset[0], refOffset[1]);
  873.         }
  874.       }
  875.     }
  876.     // update tokens with position
  877.     for (Entry<Integer, Set<String>> updateItem : updateList
  878.         .get(UPDATE_TYPE_POSITION).entrySet()) {
  879.       HashSet<String> refIdList = new HashSet<>();
  880.       for (String refId : updateItem.getValue()) {
  881.         if (idPositions.containsKey(refId)) {
  882.           refIdList.add(refId);
  883.         }
  884.         if (relationKeyMap.containsKey(refId)) {
  885.           refIdList.addAll(recursiveCollect(refId, relationKeyMap, 10));
  886.         }
  887.       }
  888.       for (String refId : refIdList) {
  889.         Set<Integer> refPositions = idPositions.get(refId);
  890.         Integer tokenId = updateItem.getKey();
  891.         if (tokenId != null && refPositions != null) {
  892.           MtasToken token = tokenCollection.get(tokenId);
  893.           token.addPositions(refPositions);
  894.         }
  895.       }
  896.     }
  897.     // final check
  898.     tokenCollection.check(autorepair, makeunique);
  899.     return tokenCollection;
  900.   }

  902.   /**
  903.    * Recursive collect.
  904.    *
  905.    * @param refId the ref id
  906.    * @param relationKeyMap the relation key map
  907.    * @param maxRecursion the max recursion
  908.    * @return the collection<? extends string>
  909.    */
  910.   private Collection<? extends String> recursiveCollect(String refId,
  911.       Map<String, SortedSet<String>> relationKeyMap, int maxRecursion) {
  912.     Set<String> list = new HashSet<>();
  913.     if (maxRecursion > 0 && relationKeyMap.containsKey(refId)) {
  914.       SortedSet<String> subList = relationKeyMap.get(refId);
  915.       for (String subRefId : subList) {
  916.         list.add(subRefId);
  917.         list.addAll(
  918.             recursiveCollect(subRefId, relationKeyMap, maxRecursion - 1));
  919.       }
  920.     }
  921.     return list;
  922.   }

  924.   /**
  925.    * Gets the q name.
  926.    *
  927.    * @param key the key
  928.    * @return the q name
  929.    */
  930.   private QName getQName(String key) {
  931.     QName qname;
  932.     if ((qname = qNames.get(key)) == null) {
  933.       qname = new QName(namespaceURI, key);
  934.       qNames.put(key, qname);
  935.     }
  936.     return qname;
  937.   }

  939.   /**
  940.    * Collect attributes.
  941.    *
  942.    * @param currentObject the current object
  943.    * @param streamReader the stream reader
  944.    */
  945.   public void collectAttributes(MtasParserObject currentObject,
  946.       XMLStreamReader streamReader) {
  947.     String attributeNamespaceURI;
  948.     currentObject.objectAttributes.clear();
  949.     currentObject.objectId = streamReader.getAttributeValue(namespaceURI_id,
  950.         "id");
  951.     for (int i = 0; i < streamReader.getAttributeCount(); i++) {
  952.       attributeNamespaceURI = streamReader.getAttributeNamespace(i);
  953.       if (attributeNamespaceURI == null || attributeNamespaceURI.equals("")) {
  954.         attributeNamespaceURI = streamReader.getNamespaceURI();
  955.       }
  956.       if (namespaceURI == null || attributeNamespaceURI.equals(namespaceURI)) {
  957.         currentObject.objectAttributes.put(
  958.             streamReader.getAttributeLocalName(i),
  959.             streamReader.getAttributeValue(i));
  960.       } else {
  961.         HashMap<String, String> otherMap;
  962.         if(!currentObject.objectOtherAttributes.containsKey(attributeNamespaceURI)) {
  963.            otherMap = new HashMap<>();          
  964.           currentObject.objectOtherAttributes.put(attributeNamespaceURI, otherMap);
  965.         } else {
  966.           otherMap = currentObject.objectOtherAttributes.get(attributeNamespaceURI);
  967.         }
  968.         otherMap.put(
  969.             streamReader.getAttributeLocalName(i),
  970.             streamReader.getAttributeValue(i));
  971.       }
  972.     }
  973.   }

  975.   /**
  976.    * The Class MtasXMLParserMappingRelation.
  977.    */
  978.   private class MtasXMLParserMappingRelation
  979.       extends MtasParserMapping<MtasXMLParserMappingRelation> {

  981.     /**
  982.      * Instantiates a new mtas XML parser mapping relation.
  983.      */
  984.     public MtasXMLParserMappingRelation() {
  985.       super();
  986.       this.position = SOURCE_REFS;
  987.       this.realOffset = SOURCE_OWN;
  988.       this.offset = SOURCE_REFS;
  989.       this.type = MAPPING_TYPE_RELATION;
  990.     }

  992.     /*
  993.      * (non-Javadoc)
  994.      * 
  995.      * @see mtas.analysis.parser.MtasBasicParser.MtasParserMapping#self()
  996.      */
  997.     @Override
  998.     protected MtasXMLParserMappingRelation self() {
  999.       return this;
  1000.     }
  1001.   }

  1003.   /**
  1004.    * The Class MtasXMLParserMappingRelationAnnotation.
  1005.    */
  1006.   private class MtasXMLParserMappingRelationAnnotation
  1007.       extends MtasParserMapping<MtasXMLParserMappingRelationAnnotation> {

  1009.     /**
  1010.      * Instantiates a new mtas XML parser mapping relation annotation.
  1011.      */
  1012.     public MtasXMLParserMappingRelationAnnotation() {
  1013.       super();
  1014.       this.position = SOURCE_ANCESTOR_RELATION;
  1015.       this.realOffset = SOURCE_OWN;
  1016.       this.offset = SOURCE_ANCESTOR_RELATION;
  1017.       this.type = MAPPING_TYPE_RELATION_ANNOTATION;
  1018.     }

  1020.     /*
  1021.      * (non-Javadoc)
  1022.      * 
  1023.      * @see mtas.analysis.parser.MtasBasicParser.MtasParserMapping#self()
  1024.      */
  1025.     @Override
  1026.     protected MtasXMLParserMappingRelationAnnotation self() {
  1027.       return this;
  1028.     }

  1030.   }

  1032.   /**
  1033.    * The Class MtasXMLParserMappingGroup.
  1034.    */
  1035.   private class MtasXMLParserMappingGroup
  1036.       extends MtasParserMapping<MtasXMLParserMappingGroup> {

  1038.     /**
  1039.      * Instantiates a new mtas XML parser mapping group.
  1040.      */
  1041.     public MtasXMLParserMappingGroup() {
  1042.       super();
  1043.       this.position = SOURCE_OWN;
  1044.       this.realOffset = SOURCE_OWN;
  1045.       this.offset = SOURCE_OWN;
  1046.       this.type = MAPPING_TYPE_GROUP;
  1047.     }

  1049.     /*
  1050.      * (non-Javadoc)
  1051.      * 
  1052.      * @see mtas.analysis.parser.MtasBasicParser.MtasParserMapping#self()
  1053.      */
  1054.     @Override
  1055.     protected MtasXMLParserMappingGroup self() {
  1056.       return this;
  1057.     }
  1058.   }

  1060.   /**
  1061.    * The Class MtasXMLParserMappingGroupAnnotation.
  1062.    */
  1063.   private class MtasXMLParserMappingGroupAnnotation
  1064.       extends MtasParserMapping<MtasXMLParserMappingGroupAnnotation> {

  1066.     /**
  1067.      * Instantiates a new mtas XML parser mapping group annotation.
  1068.      */
  1069.     public MtasXMLParserMappingGroupAnnotation() {
  1070.       super();
  1071.       this.position = SOURCE_ANCESTOR_GROUP;
  1072.       this.realOffset = SOURCE_OWN;
  1073.       this.offset = SOURCE_ANCESTOR_GROUP;
  1074.       this.type = MAPPING_TYPE_GROUP_ANNOTATION;
  1075.     }

  1077.     /*
  1078.      * (non-Javadoc)
  1079.      * 
  1080.      * @see mtas.analysis.parser.MtasBasicParser.MtasParserMapping#self()
  1081.      */
  1082.     @Override
  1083.     protected MtasXMLParserMappingGroupAnnotation self() {
  1084.       return this;
  1085.     }

  1087.     /*
  1088.      * (non-Javadoc)
  1089.      * 
  1090.      * @see
  1091.      * mtas.analysis.parser.MtasBasicParser.MtasParserMapping#setStartEnd(java.
  1092.      * lang.String, java.lang.String)
  1093.      */
  1094.     @Override
  1095.     protected void setStartEnd(String start, String end) {
  1096.       super.setStartEnd(start, end);
  1097.       if (start != null && end != null) {
  1098.         position = SOURCE_REFS;
  1099.         offset = SOURCE_REFS;
  1100.       }
  1101.     }

  1103.   }

  1105.   /**
  1106.    * The Class MtasXMLParserMappingWord.
  1107.    */
  1108.   private class MtasXMLParserMappingWord
  1109.       extends MtasParserMapping<MtasXMLParserMappingWord> {

  1111.     /**
  1112.      * Instantiates a new mtas XML parser mapping word.
  1113.      */
  1114.     public MtasXMLParserMappingWord() {
  1115.       super();
  1116.       this.position = SOURCE_OWN;
  1117.       this.realOffset = SOURCE_OWN;
  1118.       this.offset = SOURCE_OWN;
  1119.       this.type = MAPPING_TYPE_WORD;
  1120.     }

  1122.     /*
  1123.      * (non-Javadoc)
  1124.      * 
  1125.      * @see mtas.analysis.parser.MtasBasicParser.MtasParserMapping#self()
  1126.      */
  1127.     @Override
  1128.     protected MtasXMLParserMappingWord self() {
  1129.       return this;
  1130.     }
  1131.   }

  1133.   /**
  1134.    * The Class MtasXMLParserMappingWordAnnotation.
  1135.    */
  1136.   private class MtasXMLParserMappingWordAnnotation
  1137.       extends MtasParserMapping<MtasXMLParserMappingWordAnnotation> {

  1139.     /**
  1140.      * Instantiates a new mtas XML parser mapping word annotation.
  1141.      */
  1142.     public MtasXMLParserMappingWordAnnotation() {
  1143.       super();
  1144.       this.position = SOURCE_OWN;
  1145.       this.realOffset = SOURCE_OWN;
  1146.       this.offset = SOURCE_ANCESTOR_WORD;
  1147.       this.type = MAPPING_TYPE_WORD_ANNOTATION;
  1148.     }

  1150.     /*
  1151.      * (non-Javadoc)
  1152.      * 
  1153.      * @see mtas.analysis.parser.MtasBasicParser.MtasParserMapping#self()
  1154.      */
  1155.     @Override
  1156.     protected MtasXMLParserMappingWordAnnotation self() {
  1157.       return this;
  1158.     }
  1159.   }

  1161. }
Created with JaCoCo 0.7.9.201702052155