MtasCRMParser.java

  1. package mtas.analysis.parser;

  3. import java.io.IOException;
  4. import java.io.Reader;
  5. import java.util.ArrayList;
  6. import java.util.Arrays;
  7. import java.util.Collection;
  8. import java.util.HashMap;
  9. import java.util.HashSet;
  10. import java.util.List;
  11. import java.util.Map;
  12. import java.util.Map.Entry;
  13. import java.util.Set;
  14. import java.util.concurrent.atomic.AtomicInteger;
  15. import java.util.regex.Matcher;
  16. import java.util.regex.Pattern;

  18. import org.apache.commons.logging.Log;
  19. import org.apache.commons.logging.LogFactory;

  21. import mtas.analysis.token.MtasTokenCollection;
  22. import mtas.analysis.token.MtasTokenIdFactory;
  23. import mtas.analysis.util.MtasBufferedReader;
  24. import mtas.analysis.util.MtasConfigException;
  25. import mtas.analysis.util.MtasConfiguration;
  26. import mtas.analysis.util.MtasParserException;

  28. /**
  29.  * The Class MtasCRMParser.
  30.  */

  32. public class MtasCRMParser extends MtasBasicParser {

  34.   /** The Constant log. */
  35.   private static final Log log = LogFactory.getLog(MtasCRMParser.class);

  37.   /** The word type. */
  38.   private MtasParserType<MtasParserMapping<?>> wordType = null;

  40.   /** The word annotation types. */
  41.   private HashMap<String, MtasParserType<MtasParserMapping<?>>> wordAnnotationTypes = new HashMap<>();

  43.   /** The crm sentence types. */
  44.   private HashMap<String, MtasParserType<MtasParserMapping<?>>> crmSentenceTypes = new HashMap<>();

  46.   /** The crm clause types. */
  47.   private HashMap<String, MtasParserType<MtasParserMapping<?>>> crmClauseTypes = new HashMap<>();

  49.   /** The crm pair types. */
  50.   private HashMap<String, MtasParserType<MtasParserMapping<?>>> crmPairTypes = new HashMap<>();

  52.   /** The functions. */
  53.   private HashMap<String, HashMap<String, MtasCRMParserFunction>> functions = new HashMap<>();

  55.   private HashMap<Integer, HashMap<String, String>> filterReplace = new HashMap<>();

  57.   /** The Constant MAPPING_TYPE_CRM_SENTENCE. */
  58.   protected static final String MAPPING_TYPE_CRM_SENTENCE = "crmSentence";

  60.   /** The Constant MAPPING_TYPE_CRM_CLAUSE. */
  61.   protected static final String MAPPING_TYPE_CRM_CLAUSE = "crmClause";

  63.   /** The Constant MAPPING_TYPE_CRM_PAIR. */
  64.   protected static final String MAPPING_TYPE_CRM_PAIR = "crmPair";

  66.   protected static final String FILTER_TYPE_REPLACE = "replace";

  68.   
  69.   /** The history pair. */
  70.   private HashMap<String, HashMap<String, MtasParserObject>> historyPair = new HashMap<>();

  72.   /** The pair pattern. */
  73.   Pattern pairPattern = Pattern.compile("^([b|e])([a-z])([0-9]+)$");

  75.   /**
  76.    * Instantiates a new mtas CRM parser.
  77.    *
  78.    * @param config the config
  79.    */
  80.   public MtasCRMParser(MtasConfiguration config) {
  81.     super(config);
  82.     try {
  83.       initParser();
  84.       // System.out.print(printConfig());
  85.     } catch (MtasConfigException e) {
  86.       log.error(e);
  87.     }
  88.   }

  90.   /*
  91.    * (non-Javadoc)
  92.    * 
  93.    * @see mtas.analysis.parser.MtasParser#initParser()
  94.    */
  95.   @SuppressWarnings("unchecked")
  96.   @Override
  97.   protected void initParser() throws MtasConfigException {
  98.     super.initParser();
  99.     if (config != null) {
  100.       // always word, no mappings
  101.       wordType = new MtasParserType<>(MAPPING_TYPE_WORD, null, false);
  102.       for (int i = 0; i < config.children.size(); i++) {
  103.         MtasConfiguration current = config.children.get(i);
  104.         if (current.name.equals("filters")) {
  105.           for (int j = 0; j < current.children.size(); j++) {
  106.             if (current.children.get(j).name.equals("filter")) {
  107.               MtasConfiguration filter = current.children.get(j);
  108.               String typeFilter = filter.attributes.get("type");
  109.               String nameFilter = filter.attributes.get("name");
  110.               if(typeFilter!=null) {
  111.                 if(typeFilter.equals(FILTER_TYPE_REPLACE)) {
  112.                   String value = filter.attributes.get("value");
  113.                   String replace = filter.attributes.get("replace");
  114.                   if(nameFilter!=null && value!=null && replace!=null) {
  115.                     String[] names = nameFilter.split(Pattern.quote(","));
  116.                     for(String name : names) {
  117.                       try {
  118.                         int nameInt = Integer.parseInt(name);
  119.                         HashMap<String, String> nameMap;
  120.                         if(!filterReplace.containsKey(nameInt)) {
  121.                           nameMap = new HashMap<>();
  122.                           filterReplace.put(nameInt, nameMap);
  123.                         } else {
  124.                           nameMap = filterReplace.get(nameInt);
  125.                         }
  126.                         nameMap.put(value, replace);
  127.                       } catch (NumberFormatException e) {
  128.                         log.info(e);                        
  129.                       }                      
  130.                     }                    
  131.                   } else {
  132.                     throw new MtasConfigException("no name, value or replace for filter "
  133.                         + typeFilter );
  134.                   }
  135.                 } else {
  136.                   throw new MtasConfigException("unknown filter type "
  137.                       + typeFilter );
  138.                 }
  139.               } else {
  140.                 throw new MtasConfigException("no type provided for filter" );
  141.               }
  142.             }
  143.           }  
  144.         } else if (current.name.equals("mappings")) {
  145.           for (int j = 0; j < current.children.size(); j++) {
  146.             if (current.children.get(j).name.equals("mapping")) {
  147.               MtasConfiguration mapping = current.children.get(j);
  148.               String typeMapping = mapping.attributes.get("type");
  149.               String nameMapping = mapping.attributes.get("name");
  150.               if ((typeMapping != null)) {
  151.                 if (typeMapping.equals(MAPPING_TYPE_WORD)) {
  152.                   MtasCRMParserMappingWordAnnotation m = new MtasCRMParserMappingWordAnnotation();
  153.                   m.processConfig(mapping);
  154.                   wordType.addItem(m);
  155.                 } else if (typeMapping.equals(MAPPING_TYPE_WORD_ANNOTATION)
  156.                     && (nameMapping != null)) {
  157.                   MtasCRMParserMappingWordAnnotation m = new MtasCRMParserMappingWordAnnotation();
  158.                   m.processConfig(mapping);
  159.                   if (wordAnnotationTypes.containsKey(nameMapping)) {
  160.                     wordAnnotationTypes.get(nameMapping).addItem(m);
  161.                   } else {
  162.                     MtasParserType<MtasParserMapping<?>> t = new MtasParserType<>(
  163.                         typeMapping, nameMapping, false);
  164.                     t.addItem(m);
  165.                     wordAnnotationTypes.put(nameMapping, t);
  166.                   }
  167.                 } else if (typeMapping.equals(MAPPING_TYPE_CRM_SENTENCE)) {
  168.                   MtasCRMParserMappingCRMSentence m = new MtasCRMParserMappingCRMSentence();
  169.                   m.processConfig(mapping);
  170.                   if (crmSentenceTypes.containsKey(nameMapping)) {
  171.                     crmSentenceTypes.get(nameMapping).addItem(m);
  172.                   } else {
  173.                     MtasParserType<MtasParserMapping<?>> t = new MtasParserType<>(
  174.                         MAPPING_TYPE_GROUP, nameMapping, true);
  175.                     t.addItem(m);
  176.                     crmSentenceTypes.put(nameMapping, t);
  177.                   }
  178.                 } else if (typeMapping.equals(MAPPING_TYPE_CRM_CLAUSE)) {
  179.                   MtasCRMParserMappingCRMSentence m = new MtasCRMParserMappingCRMSentence();
  180.                   m.processConfig(mapping);
  181.                   if (crmClauseTypes.containsKey(nameMapping)) {
  182.                     crmClauseTypes.get(nameMapping).addItem(m);
  183.                   } else {
  184.                     MtasParserType<MtasParserMapping<?>> t = new MtasParserType<>(
  185.                         MAPPING_TYPE_GROUP, nameMapping, true);
  186.                     t.addItem(m);
  187.                     crmClauseTypes.put(nameMapping, t);
  188.                   }
  189.                 } else if (typeMapping.equals(MAPPING_TYPE_CRM_PAIR)) {
  190.                   MtasCRMParserMappingCRMPair m = new MtasCRMParserMappingCRMPair();
  191.                   m.processConfig(mapping);
  192.                   if (crmPairTypes.containsKey(nameMapping)) {
  193.                     crmPairTypes.get(nameMapping).addItem(m);
  194.                   } else {
  195.                     MtasParserType<MtasParserMapping<?>> t = new MtasParserType<>(
  196.                         MAPPING_TYPE_RELATION, nameMapping, true);
  197.                     t.addItem(m);
  198.                     crmPairTypes.put(nameMapping, t);
  199.                   }
  200.                 } else {
  201.                   throw new MtasConfigException("unknown mapping type "
  202.                       + typeMapping + " or missing name");
  203.                 }
  204.               }
  205.             }
  206.           }
  207.         } else if (current.name.equals("functions")) {
  208.           for (int j = 0; j < current.children.size(); j++) {
  209.             if (current.children.get(j).name.equals("function")) {
  210.               MtasConfiguration function = current.children.get(j);
  211.               String nameFunction = function.attributes.get("name");
  212.               String typeFunction = function.attributes.get("type");
  213.               String splitFunction = function.attributes.get("split");
  214.               if (nameFunction != null && typeFunction != null) {
  215.                 MtasCRMParserFunction mtasCRMParserFunction = new MtasCRMParserFunction(
  216.                     typeFunction, splitFunction);
  217.                 if (!functions.containsKey(typeFunction)) {
  218.                   functions.put(typeFunction,
  219.                       new HashMap<String, MtasCRMParserFunction>());
  220.                 }
  221.                 functions.get(typeFunction).put(nameFunction,
  222.                     mtasCRMParserFunction);
  223.                 MtasConfiguration subCurrent = current.children.get(j);
  224.                 for (int k = 0; k < subCurrent.children.size(); k++) {
  225.                   if (subCurrent.children.get(k).name.equals("condition")) {
  226.                     MtasConfiguration subSubCurrent = subCurrent.children
  227.                         .get(k);
  228.                     if (subSubCurrent.attributes.containsKey("value")) {
  229.                       String[] valuesCondition = subSubCurrent.attributes
  230.                           .get("value").split(Pattern.quote(","));
  231.                       ArrayList<MtasCRMParserFunctionOutput> valueOutputList = new ArrayList<>();
  232.                       for (int l = 0; l < subSubCurrent.children.size(); l++) {
  233.                         if (subSubCurrent.children.get(l).name
  234.                             .equals("output")) {
  235.                           String valueOutput = subSubCurrent.children
  236.                               .get(l).attributes.get("value");
  237.                           String nameOutput = subSubCurrent.children
  238.                               .get(l).attributes.get("name");
  239.                           if (nameOutput != null) {
  240.                             MtasCRMParserFunctionOutput o = new MtasCRMParserFunctionOutput(
  241.                                 nameOutput, valueOutput);
  242.                             valueOutputList.add(o);
  243.                           }
  244.                         }
  245.                       }
  246.                       if (!valueOutputList.isEmpty()) {
  247.                         for (String valueCondition : valuesCondition) {
  248.                           if (mtasCRMParserFunction.output
  249.                               .containsKey(valueCondition)) {
  250.                             mtasCRMParserFunction.output.get(valueCondition)
  251.                                 .addAll(
  252.                                     (Collection<? extends MtasCRMParserFunctionOutput>) valueOutputList
  253.                                         .clone());
  254.                           } else {
  255.                             mtasCRMParserFunction.output.put(valueCondition,
  256.                                 (ArrayList<MtasCRMParserFunctionOutput>) valueOutputList
  257.                                     .clone());
  258.                           }
  259.                         }
  260.                       }
  261.                     }
  262.                   }
  263.                 }
  264.               }
  265.             }
  266.           }
  267.         }
  268.       }
  269.     }
  270.   }

  272.   /*
  273.    * (non-Javadoc)
  274.    * 
  275.    * @see mtas.analysis.parser.MtasParser#createTokenCollection(java.io.Reader)
  276.    */
  277.   @Override
  278.   public MtasTokenCollection createTokenCollection(Reader reader)
  279.       throws MtasParserException, MtasConfigException {
  280.     AtomicInteger position = new AtomicInteger(0);
  281.     MtasCRMAncestors unknownAncestors = new MtasCRMAncestors();

  283.     Map<String, Set<Integer>> idPositions = new HashMap<>();
  284.     Map<String, Integer[]> idOffsets = new HashMap<>();

  286.     Map<String, Map<Integer, Set<String>>> updateList = createUpdateList();
  287.     Map<String, List<MtasParserObject>> currentList = createCurrentList();

  289.     tokenCollection = new MtasTokenCollection();
  290.     MtasTokenIdFactory mtasTokenIdFactory = new MtasTokenIdFactory();
  291.     try (MtasBufferedReader br = new MtasBufferedReader(reader)) {
  292.       String line;
  293.       int currentOffset;
  294.       int previousOffset = br.getPosition();
  295.       MtasParserObject currentObject;
  296.       Pattern headerPattern = Pattern.compile("^@ @ @(.*)$");
  297.       Pattern regularPattern = Pattern.compile(
  298.           "^([^ ]+) ([^ ]+) ([^ ]+) ([^ ]+) ([^ ]+) ([^ ]+) ([^ ]+) ([^ ]+)$");
  299.       Matcher matcherHeader;
  300.       Matcher matcherRegular = null;
  301.       Set<MtasParserObject> newPreviousSentence = new HashSet<>();
  302.       Set<MtasParserObject> previousSentence = new HashSet<>();
  303.       Set<MtasParserObject> newPreviousClause = new HashSet<>();
  304.       Set<MtasParserObject> previousClause = new HashSet<>(); 
  305.       String[] matcherList = new String[8];
  306.       while ((line = br.readLine()) != null) {
  307.         currentOffset = br.getPosition();
  308.         matcherHeader = headerPattern.matcher(line.trim());
  309.         matcherRegular = regularPattern.matcher(line.trim());
  310.         if (matcherRegular.matches()) {
  311.           newPreviousSentence.clear();
  312.           matcherList = createMatcherList(matcherRegular); 
  313.           for (int i = 4; i < 8; i++) {
  314.             List<MtasCRMParserFunctionOutput> functionOutputList = new ArrayList<>();
  315.             Set<MtasParserObject> tmpList = processCRMSentence(
  316.                 mtasTokenIdFactory, String.valueOf(i),
  317.                 matcherList[i], currentOffset,
  318.                 functionOutputList, unknownAncestors, currentList, updateList,
  319.                 idPositions, idOffsets, previousSentence, previousClause);
  320.             if (tmpList != null) {
  321.               newPreviousSentence.addAll(tmpList);
  322.             }
  323.             for (MtasCRMParserFunctionOutput functionOutput : functionOutputList) {
  324.               tmpList = processCRMSentence(mtasTokenIdFactory,
  325.                   functionOutput.name, functionOutput.value, currentOffset,
  326.                   functionOutputList, unknownAncestors, currentList, updateList,
  327.                   idPositions, idOffsets, previousSentence, previousClause);
  328.               if (tmpList != null) {
  329.                 newPreviousSentence.addAll(tmpList);
  330.               }
  331.             }
  332.           }
  333.           if (!newPreviousSentence.isEmpty()) {
  334.             previousSentence.clear();
  335.             previousSentence.addAll(newPreviousSentence);
  336.           }
  337.           newPreviousClause.clear();
  338.           for (int i = 4; i < 8; i++) {
  339.             ArrayList<MtasCRMParserFunctionOutput> functionOutputList = new ArrayList<>();
  340.             Set<MtasParserObject> tmpList = processCRMClause(mtasTokenIdFactory,
  341.                 String.valueOf(i), matcherList[i], currentOffset,
  342.                 functionOutputList, unknownAncestors, currentList, updateList,
  343.                 idPositions, idOffsets, previousClause);
  344.             if (tmpList != null) {
  345.               newPreviousClause.addAll(tmpList);
  346.             }
  347.             for (MtasCRMParserFunctionOutput functionOutput : functionOutputList) {
  348.               tmpList = processCRMClause(mtasTokenIdFactory,
  349.                   functionOutput.name, functionOutput.value, currentOffset,
  350.                   functionOutputList, unknownAncestors, currentList, updateList,
  351.                   idPositions, idOffsets, previousClause);
  352.               if (tmpList != null) {
  353.                 newPreviousClause.addAll(tmpList);
  354.               }
  355.             }
  356.           }
  357.           if (!newPreviousClause.isEmpty()) {
  358.             previousClause.clear();
  359.             previousClause.addAll(newPreviousClause);
  360.           }
  361.         }

  363.         if (matcherRegular.matches() && !matcherHeader.matches()) {
  364.           matcherRegular = regularPattern.matcher(line.trim());
  365.           if (matcherRegular.matches()) {
  366.             // regular line - start word
  367.             currentObject = new MtasParserObject(wordType);
  368.             currentObject.setOffsetStart(previousOffset);
  369.             currentObject.setRealOffsetStart(previousOffset);
  370.             currentObject.setUnknownAncestorNumber(unknownAncestors.unknown);
  371.             if (!prevalidateObject(currentObject, currentList)) {
  372.               unknownAncestors.unknown++;
  373.             } else {
  374.               int p = position.getAndIncrement();
  375.               currentObject.addPosition(p);
  376.               currentObject.objectId = "word_" + p;
  377.               currentList.get(MAPPING_TYPE_WORD).add(currentObject);
  378.               unknownAncestors.unknown = 0;
  379.               // check for crmPair
  380.               for (int i = 0; i < 8; i++) {
  381.                 List<MtasCRMParserFunctionOutput> functionOutputList = new ArrayList<>();
  382.                 processCRMPair(mtasTokenIdFactory, p, String.valueOf(i),
  383.                     matcherList[i], currentOffset,
  384.                     functionOutputList, unknownAncestors, currentList,
  385.                     updateList, idPositions, idOffsets);
  386.                 for (MtasCRMParserFunctionOutput functionOutput : functionOutputList) {
  387.                   processCRMPair(mtasTokenIdFactory, p, functionOutput.name,
  388.                       functionOutput.value, currentOffset, functionOutputList,
  389.                       unknownAncestors, currentList, updateList, idPositions,
  390.                       idOffsets);
  391.                 }
  392.               }
  393.               // compute word annotations
  394.               for (int i = 0; i < 8; i++) {
  395.                 ArrayList<MtasCRMParserFunctionOutput> functionOutputList = new ArrayList<>();
  396.                 functionOutputList
  397.                     .addAll(processWordAnnotation(mtasTokenIdFactory,
  398.                         String.valueOf(i), matcherList[i],
  399.                         previousOffset, currentOffset, unknownAncestors,
  400.                         currentList, updateList, idPositions, idOffsets));
  401.                 for (MtasCRMParserFunctionOutput functionOutput : functionOutputList) {
  402.                   processWordAnnotation(mtasTokenIdFactory, functionOutput.name,
  403.                       functionOutput.value, previousOffset, currentOffset,
  404.                       unknownAncestors, currentList, updateList, idPositions,
  405.                       idOffsets);
  406.                 }
  407.               }
  408.             }
  409.             // finish word
  410.             if (unknownAncestors.unknown > 0) {
  411.               unknownAncestors.unknown--;
  412.             } else {
  413.               currentObject = currentList.get(MAPPING_TYPE_WORD)
  414.                   .remove(currentList.get(MAPPING_TYPE_WORD).size() - 1);
  415.               assert unknownAncestors.unknown == 0 : "error in administration "
  416.                   + currentObject.getType().getName();
  417.               currentObject.setText(null);
  418.               currentObject.setOffsetEnd(currentOffset - 1);
  419.               currentObject.setRealOffsetEnd(currentOffset - 1);
  420.               // update ancestor groups with position and offset
  421.               for (MtasParserObject currentGroup : currentList
  422.                   .get(MAPPING_TYPE_GROUP)) {
  423.                 currentGroup.addPositions(currentObject.getPositions());
  424.                 currentGroup.addOffsetStart(currentObject.getOffsetStart());
  425.                 currentGroup.addOffsetEnd(currentObject.getOffsetEnd());
  426.               }
  427.               idPositions.put(currentObject.getId(),
  428.                   currentObject.getPositions());
  429.               idOffsets.put(currentObject.getId(), currentObject.getOffset());
  430.               currentObject.updateMappings(idPositions, idOffsets);
  431.               unknownAncestors.unknown = currentObject
  432.                   .getUnknownAncestorNumber();
  433.               computeMappingsFromObject(mtasTokenIdFactory, currentObject,
  434.                   currentList, updateList);
  435.             }

  437.           } else {
  438.             // System.out.println("PROBLEM: " + line);
  439.           }
  440.         }
  441.         previousOffset = br.getPosition();
  442.       }
  443.       closePrevious(mtasTokenIdFactory, previousSentence, previousOffset,
  444.           unknownAncestors, currentList, updateList, idPositions, idOffsets);
  445.       closePrevious(mtasTokenIdFactory, previousClause, previousOffset,
  446.           unknownAncestors, currentList, updateList, idPositions, idOffsets);
  447.     } catch (IOException e) {
  448.       log.debug(e);
  449.       throw new MtasParserException(e.getMessage());
  450.     }
  451.     // final check
  452.     tokenCollection.check(autorepair, makeunique);
  453.     return tokenCollection;

  455.   }

  457.   private String[] createMatcherList(Matcher matcher) {
  458.     String[] list = new String[8];
  459.     String value;
  460.     for(int i=0; i<8; i++) {
  461.       value = matcher.group((i+1));
  462.       if(filterReplace.containsKey(i)) {
  463.         for(Entry<String,String> entry : filterReplace.get(i).entrySet()) {
  464.           value = value.replaceAll(Pattern.quote(entry.getKey()), entry.getValue());
  465.         }
  466.       }
  467.       list[i] = value;
  468.     }
  469.     return list;
  470.   }
  471.   
  472.   /**
  473.    * Process word annotation.
  474.    *
  475.    * @param mtasTokenIdFactory the mtas token id factory
  476.    * @param name the name
  477.    * @param text the text
  478.    * @param previousOffset the previous offset
  479.    * @param currentOffset the current offset
  480.    * @param unknownAncestors the unknown ancestors
  481.    * @param currentList the current list
  482.    * @param updateList the update list
  483.    * @param idPositions the id positions
  484.    * @param idOffsets the id offsets
  485.    * @return the list
  486.    * @throws MtasParserException the mtas parser exception
  487.    * @throws MtasConfigException the mtas config exception
  488.    */
  489.   private List<MtasCRMParserFunctionOutput> processWordAnnotation(
  490.       MtasTokenIdFactory mtasTokenIdFactory, String name, String text,
  491.       Integer previousOffset, Integer currentOffset,
  492.       MtasCRMAncestors unknownAncestors,
  493.       Map<String, List<MtasParserObject>> currentList,
  494.       Map<String, Map<Integer, Set<String>>> updateList,
  495.       Map<String, Set<Integer>> idPositions, Map<String, Integer[]> idOffsets)
  496.       throws MtasParserException, MtasConfigException {
  497.     MtasParserType tmpCurrentType;
  498.     MtasParserObject currentObject;
  499.     List<MtasCRMParserFunctionOutput> functionOutputList = new ArrayList<>();
  500.     if ((tmpCurrentType = wordAnnotationTypes.get(name)) != null) {
  501.       // start word annotation
  502.       currentObject = new MtasParserObject(tmpCurrentType);
  503.       currentObject.setRealOffsetStart(previousOffset);
  504.       currentObject.addPositions(currentList.get(MAPPING_TYPE_WORD)
  505.           .get((currentList.get(MAPPING_TYPE_WORD).size() - 1)).getPositions());
  506.       currentObject.setUnknownAncestorNumber(unknownAncestors.unknown);
  507.       if (!prevalidateObject(currentObject, currentList)) {
  508.         unknownAncestors.unknown++;
  509.       } else {
  510.         currentList.get(MAPPING_TYPE_WORD_ANNOTATION).add(currentObject);
  511.         unknownAncestors.unknown = 0;
  512.       }
  513.       // finish word annotation
  514.       if (unknownAncestors.unknown > 0) {
  515.         unknownAncestors.unknown--;
  516.       } else {
  517.         currentObject = currentList.get(MAPPING_TYPE_WORD_ANNOTATION)
  518.             .remove(currentList.get(MAPPING_TYPE_WORD_ANNOTATION).size() - 1);
  519.         assert unknownAncestors.unknown == 0 : "error in administration "
  520.             + currentObject.getType().getName();
  521.         if (functions.containsKey(MAPPING_TYPE_WORD_ANNOTATION)
  522.             && functions.get(MAPPING_TYPE_WORD_ANNOTATION).containsKey(name)
  523.             && text != null) {
  524.           MtasCRMParserFunction function = functions
  525.               .get(MAPPING_TYPE_WORD_ANNOTATION).get(name);
  526.           String[] value;
  527.           if (function.split != null) {
  528.             value = text.split(Pattern.quote(function.split));
  529.           } else {
  530.             value = new String[] { text };
  531.           }
  532.           for (int c = 0; c < value.length; c++) {
  533.             if (function.output.containsKey(value[c])) {
  534.               functionOutputList.addAll(function.output.get(value[c]));
  535.             }
  536.           }
  537.         }
  538.         currentObject.setText(text);
  539.         currentObject.setRealOffsetEnd(currentOffset - 1);
  540.         idPositions.put(currentObject.getId(), currentObject.getPositions());
  541.         idOffsets.put(currentObject.getId(), currentObject.getOffset());
  542.         // offset always null, so update later with word (should be possible)
  543.         if ((currentObject.getId() != null)
  544.             && (!currentList.get(MAPPING_TYPE_WORD).isEmpty())) {
  545.           currentList.get(MAPPING_TYPE_WORD)
  546.               .get((currentList.get(MAPPING_TYPE_WORD).size() - 1))
  547.               .addUpdateableIdWithOffset(currentObject.getId());
  548.         }
  549.         currentObject.updateMappings(idPositions, idOffsets);
  550.         unknownAncestors.unknown = currentObject.getUnknownAncestorNumber();
  551.         computeMappingsFromObject(mtasTokenIdFactory, currentObject,
  552.             currentList, updateList);
  553.       }
  554.     }
  555.     return functionOutputList;
  556.   }

  558.   /**
  559.    * Process CRM sentence.
  560.    *
  561.    * @param mtasTokenIdFactory the mtas token id factory
  562.    * @param name the name
  563.    * @param text the text
  564.    * @param currentOffset the current offset
  565.    * @param functionOutputList the function output list
  566.    * @param unknownAncestors the unknown ancestors
  567.    * @param currentList the current list
  568.    * @param updateList the update list
  569.    * @param idPositions the id positions
  570.    * @param idOffsets the id offsets
  571.    * @param previous the previous
  572.    * @param previousClause the previous clause
  573.    * @return the sets the
  574.    * @throws MtasParserException the mtas parser exception
  575.    * @throws MtasConfigException the mtas config exception
  576.    */
  577.   private Set<MtasParserObject> processCRMSentence(
  578.       MtasTokenIdFactory mtasTokenIdFactory, String name, String text,
  579.       Integer currentOffset,
  580.       List<MtasCRMParserFunctionOutput> functionOutputList,
  581.       MtasCRMAncestors unknownAncestors,
  582.       Map<String, List<MtasParserObject>> currentList,
  583.       Map<String, Map<Integer, Set<String>>> updateList,
  584.       Map<String, Set<Integer>> idPositions, Map<String, Integer[]> idOffsets,
  585.       Set<MtasParserObject> previous, Set<MtasParserObject> previousClause)
  586.       throws MtasParserException, MtasConfigException {
  587.     MtasParserType tmpCurrentType;
  588.     MtasParserObject currentObject;
  589.     if ((tmpCurrentType = crmSentenceTypes.get(name)) != null) {
  590.       String filteredText = text.replaceAll("[^0-9\\-]", "");
  591.       currentObject = new MtasParserObject(tmpCurrentType);
  592.       currentObject.setUnknownAncestorNumber(unknownAncestors.unknown);
  593.       currentObject.setRealOffsetStart(currentOffset);
  594.       currentObject.setText(filteredText);
  595.       if (!prevalidateObject(currentObject, currentList)) {
  596.         return new HashSet<>();
  597.       } else {
  598.         closePrevious(mtasTokenIdFactory, previousClause, currentOffset,
  599.             unknownAncestors, currentList, updateList, idPositions, idOffsets);
  600.         closePrevious(mtasTokenIdFactory, previous, currentOffset,
  601.             unknownAncestors, currentList, updateList, idPositions, idOffsets);
  602.         previous.clear();
  603.         currentList.get(MAPPING_TYPE_GROUP).add(currentObject);
  604.         unknownAncestors.unknown = 0;
  605.         return new HashSet<>(Arrays.asList(currentObject));
  606.       }
  607.     }
  608.     return new HashSet<>();
  609.   }

  611.   /**
  612.    * Process CRM clause.
  613.    *
  614.    * @param mtasTokenIdFactory the mtas token id factory
  615.    * @param name the name
  616.    * @param text the text
  617.    * @param currentOffset the current offset
  618.    * @param functionOutputList the function output list
  619.    * @param unknownAncestors the unknown ancestors
  620.    * @param currentList the current list
  621.    * @param updateList the update list
  622.    * @param idPositions the id positions
  623.    * @param idOffsets the id offsets
  624.    * @param previous the previous
  625.    * @return the sets the
  626.    * @throws MtasParserException the mtas parser exception
  627.    * @throws MtasConfigException the mtas config exception
  628.    */
  629.   private Set<MtasParserObject> processCRMClause(
  630.       MtasTokenIdFactory mtasTokenIdFactory, String name, String text,
  631.       Integer currentOffset,
  632.       List<MtasCRMParserFunctionOutput> functionOutputList,
  633.       MtasCRMAncestors unknownAncestors,
  634.       Map<String, List<MtasParserObject>> currentList,
  635.       Map<String, Map<Integer, Set<String>>> updateList,
  636.       Map<String, Set<Integer>> idPositions, Map<String, Integer[]> idOffsets,
  637.       Set<MtasParserObject> previous)
  638.       throws MtasParserException, MtasConfigException {
  639.     MtasParserType tmpCurrentType;
  640.     MtasParserObject currentObject;
  641.     if ((tmpCurrentType = crmClauseTypes.get(name)) != null) {
  642.       String filteredText = text.replaceAll("[^0-9\\-]", "");
  643.       currentObject = new MtasParserObject(tmpCurrentType);
  644.       currentObject.setUnknownAncestorNumber(unknownAncestors.unknown);
  645.       currentObject.setRealOffsetStart(currentOffset);
  646.       currentObject.setText(filteredText);
  647.       if (!prevalidateObject(currentObject, currentList)) {
  648.         return new HashSet<>();
  649.       } else {
  650.         closePrevious(mtasTokenIdFactory, previous, currentOffset,
  651.             unknownAncestors, currentList, updateList, idPositions, idOffsets);
  652.         previous.clear();
  653.         currentList.get(MAPPING_TYPE_GROUP).add(currentObject);
  654.         unknownAncestors.unknown = 0;
  655.         return new HashSet<>(Arrays.asList(currentObject));
  656.       }
  657.     }
  658.     return new HashSet<>();
  659.   }

  661.   /**
  662.    * Close previous.
  663.    *
  664.    * @param mtasTokenIdFactory the mtas token id factory
  665.    * @param previous the previous
  666.    * @param currentOffset the current offset
  667.    * @param unknownAncestors the unknown ancestors
  668.    * @param currentList the current list
  669.    * @param updateList the update list
  670.    * @param idPositions the id positions
  671.    * @param idOffsets the id offsets
  672.    * @throws MtasParserException the mtas parser exception
  673.    * @throws MtasConfigException the mtas config exception
  674.    */
  675.   private void closePrevious(MtasTokenIdFactory mtasTokenIdFactory,
  676.       Set<MtasParserObject> previous, Integer currentOffset,
  677.       MtasCRMAncestors unknownAncestors,
  678.       Map<String, List<MtasParserObject>> currentList,
  679.       Map<String, Map<Integer, Set<String>>> updateList,
  680.       Map<String, Set<Integer>> idPositions, Map<String, Integer[]> idOffsets)
  681.       throws MtasParserException, MtasConfigException {
  682.     for (MtasParserObject previousObject : previous) {
  683.       previousObject.setRealOffsetEnd(currentOffset);
  684.       idPositions.put(previousObject.getId(), previousObject.getPositions());
  685.       idOffsets.put(previousObject.getId(), previousObject.getOffset());
  686.       previousObject.updateMappings(idPositions, idOffsets);
  687.       unknownAncestors.unknown = previousObject.getUnknownAncestorNumber();
  688.       computeMappingsFromObject(mtasTokenIdFactory, previousObject, currentList,
  689.           updateList);
  690.       currentList.get(MAPPING_TYPE_GROUP).remove(previousObject);
  691.     }
  692.   }

  694.   /**
  695.    * Process CRM pair.
  696.    *
  697.    * @param mtasTokenIdFactory the mtas token id factory
  698.    * @param position the position
  699.    * @param name the name
  700.    * @param text the text
  701.    * @param currentOffset the current offset
  702.    * @param functionOutputList the function output list
  703.    * @param unknownAncestors the unknown ancestors
  704.    * @param currentList the current list
  705.    * @param updateList the update list
  706.    * @param idPositions the id positions
  707.    * @param idOffsets the id offsets
  708.    * @throws MtasParserException the mtas parser exception
  709.    * @throws MtasConfigException the mtas config exception
  710.    */
  711.   private void processCRMPair(MtasTokenIdFactory mtasTokenIdFactory,
  712.       int position, String name, String text, Integer currentOffset,
  713.       List<MtasCRMParserFunctionOutput> functionOutputList,
  714.       MtasCRMAncestors unknownAncestors,
  715.       Map<String, List<MtasParserObject>> currentList,
  716.       Map<String, Map<Integer, Set<String>>> updateList,
  717.       Map<String, Set<Integer>> idPositions, Map<String, Integer[]> idOffsets)
  718.       throws MtasParserException, MtasConfigException {

  720.     MtasParserType tmpCurrentType;
  721.     MtasParserObject currentObject;

  723.     if ((tmpCurrentType = crmPairTypes.get(name)) != null) {
  724.       // get history
  725.       HashMap<String, MtasParserObject> currentNamePairHistory;
  726.       if (!historyPair.containsKey(name)) {
  727.         currentNamePairHistory = new HashMap<>();
  728.         historyPair.put(name, currentNamePairHistory);
  729.       } else {
  730.         currentNamePairHistory = historyPair.get(name);
  731.       }
  732.       Matcher m = pairPattern.matcher(text);
  733.       if (m.find()) {
  734.         String thisKey = m.group(1) + m.group(2);
  735.         String otherKey = (m.group(1).equals("b") ? "e" : "b") + m.group(2);
  736.         if (currentNamePairHistory.containsKey(otherKey)) {
  737.           currentObject = currentNamePairHistory.remove(otherKey);
  738.           currentObject.setText(currentObject.getText() + "+" + text);
  739.           currentObject.addPosition(position);
  740.           processFunctions(name, text, MAPPING_TYPE_CRM_PAIR,
  741.               functionOutputList);
  742.           currentObject.setRealOffsetEnd(currentOffset + 1);
  743.           currentObject.setOffsetEnd(currentOffset + 1);
  744.           idPositions.put(currentObject.getId(), currentObject.getPositions());
  745.           idOffsets.put(currentObject.getId(), currentObject.getOffset());
  746.           currentObject.updateMappings(idPositions, idOffsets);
  747.           unknownAncestors.unknown = currentObject.getUnknownAncestorNumber();
  748.           computeMappingsFromObject(mtasTokenIdFactory, currentObject,
  749.               currentList, updateList);
  750.         } else {
  751.           currentObject = new MtasParserObject(tmpCurrentType);
  752.           currentObject.setUnknownAncestorNumber(unknownAncestors.unknown);
  753.           currentObject.setRealOffsetStart(currentOffset);
  754.           currentObject.setOffsetStart(currentOffset);
  755.           currentObject.setText(text);
  756.           currentObject.addPosition(position);
  757.           if (!prevalidateObject(currentObject, currentList)) {
  758.             unknownAncestors.unknown++;
  759.           } else {
  760.             currentNamePairHistory.put(thisKey, currentObject);
  761.             processFunctions(name, text, MAPPING_TYPE_CRM_PAIR,
  762.                 functionOutputList);
  763.             currentObject.setRealOffsetEnd(currentOffset + 1);
  764.             currentObject.setOffsetEnd(currentOffset + 1);
  765.             idPositions.put(currentObject.getId(),
  766.                 currentObject.getPositions());
  767.             idOffsets.put(currentObject.getId(), currentObject.getOffset());
  768.             // offset always null, so update later with word (should be
  769.             // possible)
  770.             if ((currentObject.getId() != null)
  771.                 && (!currentList.get(MAPPING_TYPE_WORD).isEmpty())) {
  772.               currentList.get(MAPPING_TYPE_WORD)
  773.                   .get((currentList.get(MAPPING_TYPE_WORD).size() - 1))
  774.                   .addUpdateableIdWithOffset(currentObject.getId());
  775.             }

  777.           }
  778.         }
  779.       }

  781.     }

  783.   }

  785.   /**
  786.    * Process functions.
  787.    *
  788.    * @param name the name
  789.    * @param text the text
  790.    * @param type the type
  791.    * @param functionOutputList the function output list
  792.    */
  793.   private void processFunctions(String name, String text, String type,
  794.       List<MtasCRMParserFunctionOutput> functionOutputList) {
  795.     if (functions.containsKey(type) && functions.get(type).containsKey(name)
  796.         && text != null) {
  797.       MtasCRMParserFunction function = functions.get(type).get(name);
  798.       String[] value;
  799.       if (function.split != null) {
  800.         value = text.split(Pattern.quote(function.split));
  801.       } else {
  802.         value = new String[] { text };
  803.       }
  804.       for (int c = 0; c < value.length; c++) {
  805.         boolean checkedEmpty = false;
  806.         if (value[c].equals("")) {
  807.           checkedEmpty = true;
  808.         }
  809.         if (function.output.containsKey(value[c])) {
  810.           ArrayList<MtasCRMParserFunctionOutput> list = function.output
  811.               .get(value[c]);
  812.           for (MtasCRMParserFunctionOutput listItem : list) {
  813.             functionOutputList.add(listItem.create(value[c]));
  814.           }
  815.         }
  816.         if (!checkedEmpty && function.output.containsKey("")) {
  817.           ArrayList<MtasCRMParserFunctionOutput> list = function.output.get("");
  818.           for (MtasCRMParserFunctionOutput listItem : list) {
  819.             functionOutputList.add(listItem.create(value[c]));
  820.           }
  821.         }
  822.       }
  823.     }
  824.   }

  826.   /*
  827.    * (non-Javadoc)
  828.    * 
  829.    * @see mtas.analysis.parser.MtasParser#printConfig()
  830.    */
  831.   @Override
  832.   public String printConfig() {
  833.     StringBuilder text = new StringBuilder();
  834.     text.append("=== CONFIGURATION ===\n");
  835.     text.append("type: " + wordAnnotationTypes.size() + " x wordAnnotation");
  836.     text.append(printConfigTypes(wordAnnotationTypes));
  837.     text.append("=== CONFIGURATION ===\n");
  838.     return text.toString();
  839.   }

  841.   /**
  842.    * Prints the config types.
  843.    *
  844.    * @param types the types
  845.    * @return the string
  846.    */
  847.   private String printConfigTypes(
  848.       HashMap<?, MtasParserType<MtasParserMapping<?>>> types) {
  849.     StringBuilder text = new StringBuilder();
  850.     for (Entry<?, MtasParserType<MtasParserMapping<?>>> entry : types
  851.         .entrySet()) {
  852.       text.append("- " + entry.getKey() + ": " + entry.getValue().items.size()
  853.           + " mapping(s)\n");
  854.       for (int i = 0; i < entry.getValue().items.size(); i++) {
  855.         text.append("\t" + entry.getValue().items.get(i) + "\n");
  856.       }
  857.     }
  858.     return text.toString();
  859.   }

  861.   /**
  862.    * The Class MtasCRMAncestors.
  863.    */
  864.   private static class MtasCRMAncestors {

  866.     /** The unknown. */
  867.     public int unknown = 0;
  868.   }

  870.   /**
  871.    * The Class MtasCRMParserFunction.
  872.    */
  873.   private static class MtasCRMParserFunction {

  875.     /** The split. */
  876.     public String split;

  878.     /** The output. */
  879.     public Map<String, ArrayList<MtasCRMParserFunctionOutput>> output;

  881.     /**
  882.      * Instantiates a new mtas CRM parser function.
  883.      *
  884.      * @param type the type
  885.      * @param split the split
  886.      */
  887.     public MtasCRMParserFunction(String type, String split) {
  888.       this.split = split;
  889.       output = new HashMap<>();
  890.     }

  892.   }

  894.   /**
  895.    * The Class MtasCRMParserFunctionOutput.
  896.    */
  897.   private class MtasCRMParserFunctionOutput {

  899.     /** The name. */
  900.     public String name;

  902.     /** The value. */
  903.     public String value;

  905.     /**
  906.      * Instantiates a new mtas CRM parser function output.
  907.      *
  908.      * @param name the name
  909.      * @param value the value
  910.      */
  911.     public MtasCRMParserFunctionOutput(String name, String value) {
  912.       this.name = name;
  913.       this.value = value;
  914.     }

  916.     /**
  917.      * Creates the.
  918.      *
  919.      * @param originalValue the original value
  920.      * @return the mtas CRM parser function output
  921.      */
  922.     public MtasCRMParserFunctionOutput create(String originalValue) {
  923.       if (value != null) {
  924.         return this;
  925.       } else {
  926.         return new MtasCRMParserFunctionOutput(name, originalValue);
  927.       }
  928.     }

  930.     /*
  931.      * (non-Javadoc)
  932.      * 
  933.      * @see java.lang.Object#toString()
  934.      */
  935.     @Override
  936.     public String toString() {
  937.       return "MtasCRMParserFunctionOutput[" + name + "," + value + "]";
  938.     }
  939.   }

  941.   /**
  942.    * The Class MtasCRMParserMappingWordAnnotation.
  943.    */
  944.   private class MtasCRMParserMappingWordAnnotation
  945.       extends MtasParserMapping<MtasCRMParserMappingWordAnnotation> {

  947.     /**
  948.      * Instantiates a new mtas CRM parser mapping word annotation.
  949.      */
  950.     public MtasCRMParserMappingWordAnnotation() {
  951.       super();
  952.       this.position = SOURCE_OWN;
  953.       this.realOffset = SOURCE_OWN;
  954.       this.offset = SOURCE_ANCESTOR_WORD;
  955.       this.type = MAPPING_TYPE_WORD_ANNOTATION;
  956.     }

  958.     /*
  959.      * (non-Javadoc)
  960.      * 
  961.      * @see mtas.analysis.parser.MtasParser.MtasParserMapping#self()
  962.      */
  963.     @Override
  964.     protected MtasCRMParserMappingWordAnnotation self() {
  965.       return this;
  966.     }
  967.   }

  969.   /**
  970.    * The Class MtasCRMParserMappingCRMSentence.
  971.    */
  972.   private class MtasCRMParserMappingCRMSentence
  973.       extends MtasParserMapping<MtasCRMParserMappingCRMSentence> {

  975.     /**
  976.      * Instantiates a new mtas CRM parser mapping CRM sentence.
  977.      */
  978.     public MtasCRMParserMappingCRMSentence() {
  979.       super();
  980.       this.position = SOURCE_OWN;
  981.       this.realOffset = SOURCE_OWN;
  982.       this.offset = SOURCE_OWN;
  983.       this.type = MAPPING_TYPE_GROUP;
  984.     }

  986.     /*
  987.      * (non-Javadoc)
  988.      * 
  989.      * @see mtas.analysis.parser.MtasBasicParser.MtasParserMapping#self()
  990.      */
  991.     @Override
  992.     protected MtasCRMParserMappingCRMSentence self() {
  993.       return this;
  994.     }
  995.   }

  997.   /**
  998.    * The Class MtasCRMParserMappingCRMPair.
  999.    */
  1000.   private class MtasCRMParserMappingCRMPair
  1001.       extends MtasParserMapping<MtasCRMParserMappingCRMPair> {

  1003.     /**
  1004.      * Instantiates a new mtas CRM parser mapping CRM pair.
  1005.      */
  1006.     public MtasCRMParserMappingCRMPair() {
  1007.       super();
  1008.       this.position = SOURCE_OWN;
  1009.       this.realOffset = SOURCE_OWN;
  1010.       this.offset = SOURCE_OWN;
  1011.       this.type = MAPPING_TYPE_RELATION;
  1012.     }

  1014.     /*
  1015.      * (non-Javadoc)
  1016.      * 
  1017.      * @see mtas.analysis.parser.MtasBasicParser.MtasParserMapping#self()
  1018.      */
  1019.     @Override
  1020.     protected MtasCRMParserMappingCRMPair self() {
  1021.       return this;
  1022.     }
  1023.   }

  1025. }
Created with JaCoCo 0.7.9.201702052155