Examples with AnnotationGraph annis.model.AnnotationGraph used on opensource projects

Example 6 with AnnotationGraph

use of annis.model.AnnotationGraph in project ANNIS by korpling.

the class AomAnnotateExtractor method extractData.

@Override
public List<AnnotationGraph> extractData(ResultSet resultSet) throws SQLException, DataAccessException {
    TableAccessStrategy tableAccessStrategy = outerQueryTableAccessStrategy;
    // function result
    List<AnnotationGraph> graphs = new LinkedList<>();
    // fn: match group -> annotation graph
    Map<List<Long>, AnnotationGraph> graphByMatchGroup = new HashMap<>();
    // fn: node id -> node
    Map<Long, AnnisNode> nodeById = new HashMap<>();
    // fn: edge pre order value -> edge
    Map<Long, Edge> edgeByRankID = new HashMap<>();
    // maps span that are continous to their coverage component
    Map<List<Long>, Map<Long, ComponentEntry>> keyToSpanToComponent = new HashMap<>();
    int rowNum = 0;
    while (resultSet.next()) {
        // process result by match group
        // match group is identified by the ids of the matched
        // nodes
        Array sqlKey = resultSet.getArray("key");
        Validate.isTrue(!resultSet.wasNull(), "Match group identifier must not be null");
        Validate.isTrue(sqlKey.getBaseType() == Types.BIGINT, "Key in database must be from the type \"bigint\" but was \"" + sqlKey.getBaseTypeName() + "\"");
        Long[] keyArray = (Long[]) sqlKey.getArray();
        List<Long> key = Arrays.asList(keyArray);
        if (!graphByMatchGroup.containsKey(key)) {
            log.debug("starting annotation graph for match: " + key);
            Map<Long, ComponentEntry> spans = new HashMap<>();
            AnnotationGraph graph = new AnnotationGraph();
            graphs.add(graph);
            graphByMatchGroup.put(key, graph);
            keyToSpanToComponent.put(key, spans);
            // clear mapping functions for this graph
            // assumes that the result set is sorted by key, pre
            nodeById.clear();
            edgeByRankID.clear();
            // set the matched keys
            for (Long l : key) {
                if (l != null) {
                    graph.addMatchedNodeId(l);
                }
            }
        }
        AnnotationGraph graph = graphByMatchGroup.get(key);
        Map<Long, ComponentEntry> spanToComponent = keyToSpanToComponent.get(key);
        graph.setDocumentName(new DocumentNameMapRow().mapRow(resultSet, rowNum));
        Array path = resultSet.getArray("path");
        graph.setPath((String[]) path.getArray());
        // get node data
        AnnisNode node = mapNode(resultSet, tableAccessStrategy, spanToComponent);
        // add node to graph if it is new, else get known copy
        long id = node.getId();
        if (!nodeById.containsKey(id)) {
            log.debug("new node: " + id);
            nodeById.put(id, node);
            graph.addNode(node);
        } else {
            node = nodeById.get(id);
        }
        // we now have the id of the node and the general key,
        // so we can
        // add the matched node index to the graph (if matched)
        long matchIndex = 1;
        // node.setMatchedNodeInQuery(null);
        for (Long l : key) {
            if (l != null) {
                if (id == l) {
                    node.setMatchedNodeInQuery(matchIndex);
                    break;
                }
                matchIndex++;
            }
        }
        // get edge data
        Edge edge = mapEdge(resultSet, tableAccessStrategy);
        // add edge to graph if it is new, else get known copy
        long rank_id = edge.getId();
        if (!edgeByRankID.containsKey(rank_id)) {
            // fix source references in edge
            edge.setDestination(node);
            fixNodes(edge, edgeByRankID, nodeById);
            // add edge to src and dst nodes
            node.addIncomingEdge(edge);
            AnnisNode source = edge.getSource();
            if (source != null) {
                source.addOutgoingEdge(edge);
            }
            log.debug("new edge: " + edge);
            edgeByRankID.put(edge.getId(), edge);
            graph.addEdge(edge);
        } else {
            edge = edgeByRankID.get(rank_id);
        }
        // add annotation data
        Annotation nodeAnnotation = mapAnnotation(resultSet, tableAccessStrategy, TableAccessStrategy.NODE_ANNOTATION_TABLE);
        if (nodeAnnotation != null) {
            node.addNodeAnnotation(nodeAnnotation);
        }
        Annotation edgeAnnotation = mapAnnotation(resultSet, tableAccessStrategy, TableAccessStrategy.EDGE_ANNOTATION_TABLE);
        if (edgeAnnotation != null) {
            edge.addAnnotation(edgeAnnotation);
        }
        rowNum++;
    }
    // remove edges from the graph with a source node inside the match
    for (Entry<List<Long>, AnnotationGraph> entry : graphByMatchGroup.entrySet()) {
        AnnotationGraph graph = entry.getValue();
        ListIterator<Edge> itEdge = graph.getEdges().listIterator();
        while (itEdge.hasNext()) {
            Edge edge = itEdge.next();
            if (edge.getSource() == null) {
                edge.getDestination().getIncomingEdges().remove(edge);
                itEdge.remove();
            }
        }
        Map<Long, ComponentEntry> spans = keyToSpanToComponent.get(entry.getKey());
        // filter out the continuous spans by finding all discontinuous spans
        // discontinuos spans will have a an entry for token
        createMissingSpanningRelations(graph, spans, nodeById);
    }
    return graphs;
}