DocumentUpdateHelper.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: DocumentUpdateHelper.java
 * Description: Document update helper which contains methods necessary to provide modification process
 */

/**
 * @file DocumentUpdateHelper.java
 *
 * @brief Document update helper which contains methods necessary to provide modification process
 */
package cz.vutbr.fit.knot.annotations.document;

import cz.vutbr.fit.knot.annotations.app.Constants;
import cz.vutbr.fit.knot.annotations.app.TextModification;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

/**
 * Document update helper class which contains methods necessary to provide modification process
 *
 *
 * @author Jan Paulovcak (xpaulo00 at stud.fit.vutbr.cz)
 * @brief Document update Helper
 */
public class DocumentUpdateHelper {
  
    /**
   * Search for a node with exact Xpath within a given document
   *
   * @param doc Document in which method will search for a node
   * @param path Xpath of node
   * @return Returns node on success, null otherwise
   *
   */
  public static Node getDocumentNode(Document doc, String path){
    //Evaluate XPath against Document itself
    XPath xPath = XPathFactory.newInstance().newXPath();
    NodeList nodes;
    
    try {
      nodes = (NodeList)xPath.evaluate(path, doc, XPathConstants.NODESET);
    } catch (XPathExpressionException ex) {
      Logger.getLogger(DocumentUpdateHelper.class.getName()).log(Level.SEVERE, null, ex);
      return null;
    }
    
    return nodes.item(0);
  }

  /**
   * Creates XPath for node that will be used in reversed modifications
   *
   * It uses name of child node as a stopper while counting number of nodes with the same name
   *
   * @param xpath XPath of source node
   * @param sourceNode Node used in modification
   * @param childNodeName Node name of child node
   * @param mode Mode of text modification
   */
  public static String getNodePathForReversed(String xpath, Node sourceNode, String childNodeName, int mode){
        
    StringBuilder sb = new StringBuilder(xpath.substring(0, xpath.lastIndexOf("/")+1));
    
    Node child = sourceNode.getParentNode().getFirstChild();
    
    int counter = 1;
    
    while(child != null){
      /* In insertBefore or replace mode counting has to be done just to node, before whom we inserted */
      if((child.equals(sourceNode) && mode == Constants.TEXT_MOD_INS_BEFORE) || (child.equals(sourceNode) && mode == Constants.TEXT_MOD_REPLACE)){
          break;
      }
      /* In case of insertAfter, counting has to be stop exactly one place after source node */
      if(child.equals(sourceNode) && mode == Constants.TEXT_MOD_INS_AFTER){
        if(child.getNodeName().equals(childNodeName)){
            counter++;
        }
        break;
      }

      if(child.getNodeName().equals(childNodeName)){
          counter++;
      }
      child = child.getNextSibling();
    }
    
    if(childNodeName.equals("#text")){
      sb.append("text()[").append(counter).append("]");
    }
    else{
      sb.append(childNodeName).append("[").append(counter).append("]");
    }
    
    return sb.toString();
  }
  
  /**
   * Converts node into string form
   *
   * @param root Node to convert
   * @return Returns node in string form
   *
   */
  public static String nodeToString(Node root){
      
    String rootName = root.getNodeName().toLowerCase();
        StringBuilder sb = new StringBuilder();
        
        if(root.getNodeType() != Node.TEXT_NODE){
            if(root.getNodeName().equalsIgnoreCase("br")){
                return "<br />";
            }
            else if(root.getNodeName().equalsIgnoreCase("hr")){
                return "<hr />";
            }
            
            if(root.getAttributes() != null && !rootName.equalsIgnoreCase("head"))
                sb.append("<").append(rootName)
                        .append(nodeAttributesToString(root.getAttributes())).append(">");
                
            else{
                sb.append("<").append(rootName).append(">");
            }
            
            NodeList nl = root.getChildNodes();
            for(int i = 0; i < nl.getLength(); i++){
                Node n = nl.item(i);
                if(n.getNodeType() == Node.TEXT_NODE){
                    sb.append(n.getNodeValue());
                }
                else{
                    sb.append(nodeToString(n)); 
                }
            }
            sb.append("</").append(rootName).append(">");
        }
        else{
            sb.append(root.getNodeValue());
        }
        
        return sb.toString();
  }

  /**
   * Converts all node's attributes into string form
   *
   * @param map Map with attributes
   * @return Returns attributes in string form
   *
   */
  public static String nodeAttributesToString(NamedNodeMap map){
        StringBuilder sb = new StringBuilder();
        
        for(int i = 0; i < map.getLength(); i++){
            Node n = map.item(i);
            sb.append(" ").append(n.getNodeName()).append("=\"").append(n.getNodeValue()).append("\"");
        }
              
        return sb.toString();
    }


  /**
   * Sorts list of modifications based upon two criteriums
   * First is to sort XPaths alphabetically, in descending order
   * Second is applied only in case that XPaths are the same, then the modification
   * with higher priority will be first
   * Priority levels of modifications are set within Constants module
   *
   * @param list List of modifications
   */
  public static void sortModifications(ArrayList<TextModification> list){

    Collections.sort(list, new Comparator<TextModification>() {
    
      @Override
      public int compare(TextModification  mod1, TextModification  mod2){

        int pathComp = (mod2.getPath() + "z").compareTo(mod1.getPath() + "z");
        return pathComp == 0 ? mod2.getMode() - mod1.getMode() : pathComp;

      }
    });
  }

  /**
   * Removes unnecessary elements from array list
   *
   * @param list Array list of elements
   * @param start Start position
   * @param end End position
   */
  public static void removeListElements(ArrayList<TextModification> list, int start, int end){
    ArrayList<TextModification> group1 = new ArrayList<TextModification>(list.subList(0, start));
    ArrayList<TextModification> group2 = new ArrayList<TextModification>(list.subList(end, list.size()));
    list.clear();
    list.addAll(group1);
    list.addAll(group2);
  }

}  // public class DocumentUpdateHelper