DocumentUpdate.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: DocumentUpdate.java
 * Description: Class with which update document using TextModifications
 */

/**
 * @file DocumentUpdate.java
 *
 * @brief Update of document using TextModifications
 */

/**
 * @package cz.vutbr.fit.knot.annotations.document
 * 
 * @brief Classes responsible for handling and updating of document
 */
package cz.vutbr.fit.knot.annotations.document;

import cz.vutbr.fit.knot.annotations.app.Constants;
import cz.vutbr.fit.knot.annotations.app.Localisation;
import cz.vutbr.fit.knot.annotations.app.TextModification;
import cz.vutbr.fit.knot.annotations.comet.EditorSession;
import cz.vutbr.fit.knot.annotations.fragmentUpdater.MatcherProvider;
import cz.vutbr.fit.knot.annotations.fragmentUpdater.XPathHelper;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.w3c.dom.Document;
import org.w3c.dom.DocumentFragment;
import org.w3c.dom.Element;
import org.w3c.dom.Node;

/**
 * Class which update document using TextModifications
 *
 * @author Jan Paulovcak (xpaulo00 at stud.fit.vutbr.cz)
 *
 * @brief Update of document
 */
public class DocumentUpdate {

  /**
   * Exception of DocumentUpdate class which is thrown in case of modification failure
   *
   * Contains list of reverse modifications of failed modifications
   * 
   * @brief Exception of DocumentUpdate class which is thrown in case of modification failure
   */
  public static class DocumentUpdateException extends Exception {
    /** Array of reverse modifications to reverse failed */
    private ArrayList<TextModification> reverseModifications = new ArrayList<TextModification>();
    /** Error message */
    private String errorMessage;
    /** Flag for resynchronization */
    private boolean resyncFlag;
    /** Error code */
    private Integer errorCode;

    /**
     * Adds reverse modification into array
     * 
     * @param tm Reverse modification
     */
    private void addReverseModifications(ArrayList<TextModification> tm){
      this.reverseModifications.addAll(0,tm);
    }

    /**
     * Gets array of reverse modification
     * 
     * @return Returns array of reverse modifications
     */
    public ArrayList<TextModification> getReverseModifications(){
      return reverseModifications;
    }

    /**
     * Sets error message
     * 
     * @param msg Error message
     */
    public void setErrorMessage(String msg){
      this.errorMessage = msg;
    }

    /**
     * Gets error message
     * 
     * @return Returns error message
     */
    public String getErrorMessage(){
      return errorMessage;
    }

    /**
     * Sets flag for resynchronization
     * 
     * @param flag Flag for resynchronization
     */
    public void setResyncFlag(boolean flag){
      this.resyncFlag = flag;
    }

    /**
     * Gets flag for resynchronization
     * 
     * @return Returns flag for resynchronization
     */
    public boolean getResyncFlag(){
      return resyncFlag;
    }

    /**
     * Gets error code
     * 
     * @return Returns error code
     */
    public Integer getErrorCode() {
      return errorCode;
    }

    /**
     * Sets error code
     * 
     * @param errorCode Error code
     */
    public void setErrorCode(Integer errorCode) {
      this.errorCode = errorCode;
    }
    
  }  // public static class DocumentUpdateException

  /** Document to update */
  private Document doc;
  /** Document to update serialized in string */
  private String documentString;
  /** MatcherProvider for additional methods */
  private MatcherProvider matcherProvider;
  /** List of modifications to apply */
  private ArrayList<TextModification> modificationsAL = new ArrayList<TextModification>();
  /** List of reverse modifications */
  private ArrayList<TextModification> reverseModifications = new ArrayList<TextModification>();
  /** Exception to throw */
  private DocumentUpdateException docUpdateEx = new DocumentUpdateException();
  /** Client's session */
  private EditorSession edSession;

  /**
   *  Constructor
   *
   *  @param documentString Textual content of document
   */
  public DocumentUpdate(String documentString){
    this.documentString = documentString;
    this.matcherProvider = new MatcherProvider();
  }

  /**
   * Constructor
   *
   * @param documentString Textual content of document
   * @param edSession Editor's (client's) session
   */
  public DocumentUpdate(String documentString, EditorSession edSession){
    this.documentString = documentString;
    this.edSession = edSession;
    this.matcherProvider = new MatcherProvider();
  }

  /**
   * Sets document to update
   * 
   * @param doc Document
   */
  public void setDocument(Document doc){
    this.doc = doc;
  }

  /**
   * Gets document
   *
   * @return Document
   */
  public Document getDocument(){
    return doc;
  }

  /**
   * Sets textual content of document
   * 
   * @param documentString Textual content of document
   */
  public void setDocumentString(String documentString){
    this.documentString = documentString;
  }

  /**
   * Get document textual content
   *
   * @return Document in textual form
   */
  public String getDocumentString(){
    return documentString;
  }

  /**
   * Appends new text modification which will be processed next time on update call.
   * 
   * @param modification New modification which should be performed to document.
   */
  public void appendModification(TextModification modification) {
    modificationsAL.add(modification);
  }

  /**
   * Appends new text modifications which will be processed next time on update call.
   * 
   * @param modifications New modifications which should be performed to document.
   */
  public void appendModifications(ArrayList<TextModification> modifications) {
    modificationsAL.addAll(modifications);
  }

  /**
   * Removes text modification from the modifications to be performed.
   * 
   * @param modification Text modification to be removed.
   */
  public void removeModification(TextModification modification) {
    modificationsAL.remove(modification);
  }

  /**
   * Updates document.
   * 
   * @throws cz.vutbr.fit.knot.annotations.document.DocumentUpdate.UpdateDocumentException 
   */
  public void updateDocument() throws DocumentUpdateException {
    updateDocument(false, false, modificationsAL);
  }

  /**
   * Updates document.
   * 
   * @param failed Checks whether modifying has failed
   * @param reverseRun For reverse run true, false otherwise
   * @throws cz.vutbr.fit.knot.annotations.document.DocumentUpdate.UpdateDocumentException 
   */
  public void updateDocument(boolean failed, boolean reverseRun) throws  DocumentUpdateException  {
    updateDocument(true, true, modificationsAL);
  }
  
  /**
   * Updates document.
   * 
   * @param failed Checks whether modifying has failed
   * @param reverseRun For reverse run true, false otherwise
   * @param modifications List of modifications
   * @throws cz.vutbr.fit.knot.annotations.document.DocumentUpdate.DocumentUpdateException 
   */
  private void updateDocument(boolean failed, boolean reverseRun, ArrayList<TextModification> modifications) throws DocumentUpdateException {
    
    // Nothing to update
    if (modifications.isEmpty()) {
      return;
    }

    Integer createdReversModsNum = 0;

    /*
     * User who uses protocol version 1.x - if modification fails, reverse modification will be added to message for user
     * system will skip this modification and continues to updating rest of document
     *
     * If user is using protocol version 2.0, once modification fails, system will interupt modification process and applies
     * all reversed modifications to document, to achieve the same version as was before modification process
     *
     */
    boolean skipNContinue = false;
    if(edSession.getProtocolLOD() < Constants.PROTOCOL_LOD_V2){
      skipNContinue = true;
    }

    //Creates DOM document from content within documentwrapper
    try {
      doc = matcherProvider.getDocumentFromString(documentString, false, false);
    } catch (Exception ex) {
      docUpdateEx.setErrorCode(Localisation.ERROR_36_BAD_DOCUMENT);
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
        String msg = "Unable to parse document";
        Logger.getLogger(DocumentUpdate.class.getName()).log(Level.SEVERE, null, msg);
      }
      throw docUpdateEx;
    }
    
    if(doc == null){
      return;
    }
    
    // Normalize document
    doc.normalizeDocument();

    /*
     * Sort modifications
     * NOTE: Only for protocol v1.x and if failed is equal to false
     */
    if (!failed && (edSession.getProtocolLOD() < Constants.PROTOCOL_LOD_V2)) {
      DocumentUpdateHelper.sortModifications(modifications);  
    }
    
    /*
     * Applying each of modifications
     */
    Iterator<TextModification> modsIt;
    if (!failed) {
      modsIt = modifications.iterator();
    } else {
      modsIt = reverseModifications.iterator();
    }

    while (modsIt.hasNext()) {
      TextModification tm = modsIt.next();

      //Initialize necessary variables
      String xPath = tm.getPath();
      String content = tm.getNewContent();

      //Search for a node within document
      Node sourceNode = DocumentUpdateHelper.getDocumentNode(doc, xPath);
      if(sourceNode == null){
        /* This is a special case of interrupting modification process
         * If client is using protocol ver. 1.x and modification fails, resync. message should be sent
         * to client
         * Within protocol v2 modification process is interrupted, all changes are reversed
         */
        if (skipNContinue) {
          failed = true;
          docUpdateEx.setResyncFlag(true);
          break;
        } else {
          docUpdateEx.setErrorMessage("Unable to search for a node");
          docUpdateEx.setErrorCode(Localisation.ERROR_105_MODIFICATION_SPECIFICATION);
          failed = true;
          break;
        }
      }

      // Reverse modifications can be generated only in non reverse mode
      if (!failed) {
        createdReversModsNum = generateReverseModifications(reverseModifications, tm, sourceNode);
        if (createdReversModsNum == null) {
          failed = true;
          break;
        }
      }
      
      if (tm.getMode() == Constants.TEXT_MOD_REPLACE) {
        /*
         * Replace modification
         */

        // Get modifications info
        Integer offset = tm.getOffset();
        Integer length = tm.getLength();

        // Getting parent node
        Node sourceParentNode = sourceNode.getParentNode();
        if (sourceParentNode == null) {
          /*
           * Element does not have its parent - insertion aborded Choose whether
           * skip&continue or interrupt modification process
           */
          if (skipNContinue) {
            // Add revers modification of failed modification to exception
            docUpdateEx.addReverseModifications(new ArrayList<TextModification>(reverseModifications.subList(0, createdReversModsNum)));
            continue;
          } else {
            docUpdateEx.setErrorMessage("Unable to search for a parent node");
            docUpdateEx.setErrorCode(Localisation.ERROR_33_MODULE_ERROR);
            // Remove last generated reverse modifications as, these modifications are not saved to document
            DocumentUpdateHelper.removeListElements(reverseModifications, 0, createdReversModsNum);
            failed = true;
            break;
          }
        }

        /*
         * Replacement of whole node
         */
        if (offset == null && length == null && content != null) {

          //Create content to replace
          DocumentFragment fragment;
          try {
            fragment = matcherProvider.getFragmentFromString(content);
          } catch (Exception ex) {
            String msg = "Unable to parse fragment";
            Logger.getLogger(DocumentUpdate.class.getName()).log(Level.SEVERE, null, msg);
            if (skipNContinue) {
              // Add revers modification of failed modification to exception
              docUpdateEx.addReverseModifications(new ArrayList<TextModification>(reverseModifications.subList(0, createdReversModsNum)));
              continue;
            } else {
              docUpdateEx.setErrorMessage("Unable to parse fragment");
              docUpdateEx.setErrorCode(Localisation.ERROR_105_MODIFICATION_SPECIFICATION);
              // Remove last generated reverse modifications as, these modifications are not saved to document
              DocumentUpdateHelper.removeListElements(reverseModifications, 0, createdReversModsNum);
              failed = true;
              break;
            }
          }

          /*
           * If content will be empty string, we need to do the same operations
           * as is done in deletion section Find a node which has at least one
           * sibling, however maximum depth can be "body" element
           */
          if (fragment.getTextContent().isEmpty()) {
            if (sourceNode.getChildNodes().getLength() < 2) {

              Node tmpNode = null;
              while (sourceNode.getChildNodes().getLength() < 2 && !sourceNode.getNodeName().equalsIgnoreCase("body")) {
                tmpNode = sourceNode;
                sourceNode = sourceNode.getParentNode();
              }

              sourceNode = tmpNode;
            }

            //Actualize parent node
            sourceParentNode = sourceNode.getParentNode();

            //Remove node
            sourceParentNode.removeChild(sourceNode);
          } else {
            /*
             * If fragment has some content, classic replacement of node will
             * take a place
             */

            //Import node
            Node replaceNode = doc.importNode(fragment, true);

            //Process replace
            sourceParentNode.replaceChild(replaceNode, sourceNode);

            //Merge text nodes
            sourceParentNode.normalize();
          }
        } else if (offset == null && length == null && content == null) {
          /*
           * Delete whole node
           */

          if (sourceNode.getChildNodes().getLength() < 2) {

            Node tmpNode = null;
            while (sourceNode.getChildNodes().getLength() < 2 && !sourceNode.getNodeName().equalsIgnoreCase("body")) {
              tmpNode = sourceNode;
              sourceNode = sourceNode.getParentNode();
            }

            sourceNode = tmpNode;
          }

          //Actualize parent node
          sourceParentNode = sourceNode.getParentNode();

          //Remove node
          sourceParentNode.removeChild(sourceNode);
        } else if (offset != null && length == null && content != null) {
          /*
           * Insertion to node 
           * NOTE: Can be applied only on text node
           */

          //Checking whether node is text node
          if (sourceNode.getNodeType() != Node.TEXT_NODE) {
            if (skipNContinue) {
              //Add revers modification of failed modification to exception
              docUpdateEx.addReverseModifications(new ArrayList<TextModification>(reverseModifications.subList(0, createdReversModsNum)));
              continue;
            } else {
              docUpdateEx.setErrorMessage("Unable to apply modification on non-text node");
              docUpdateEx.setErrorCode(Localisation.ERROR_105_MODIFICATION_SPECIFICATION);
              //Remove last generated reverse modifications as, these modifications are not saved to document
              DocumentUpdateHelper.removeListElements(reverseModifications, 0, createdReversModsNum);
              failed = true;
              break;
            }
          }

          // Check whether offset is not higher than node text content length
          if (offset > sourceNode.getTextContent().length()) {
            if (skipNContinue) {
              // Add revers modification of failed modification to exception
              docUpdateEx.addReverseModifications(new ArrayList<TextModification>(reverseModifications.subList(0, createdReversModsNum)));
              continue;
            } else {
              docUpdateEx.setErrorMessage("Offset extends node text content length");
              docUpdateEx.setErrorCode(Localisation.ERROR_105_MODIFICATION_SPECIFICATION);
              // Remove last generated reverse modifications as, these modifications are not saved to document
              DocumentUpdateHelper.removeListElements(reverseModifications, 0, createdReversModsNum);
              failed = true;
              break;
            }
          }

          // String containing prepared requested content to parse
          String tmpStr = sourceNode.getTextContent().substring(0, offset) + content + sourceNode.getTextContent().substring(offset);

          // Create document fragment from content of requested modification
          DocumentFragment fragment;
          try {
            fragment = matcherProvider.getFragmentFromString(tmpStr);
          } catch (Exception ex) {
            String msg = "Unable to parse fragment";
            Logger.getLogger(DocumentUpdate.class.getName()).log(Level.SEVERE, null, msg);
            if (skipNContinue) {
              // Add revers modification of failed modification to exception
              docUpdateEx.addReverseModifications(new ArrayList<TextModification>(reverseModifications.subList(0, createdReversModsNum)));
              continue;
            } else {
              docUpdateEx.setErrorMessage("Unable to parse fragment");
              docUpdateEx.setErrorCode(Localisation.ERROR_105_MODIFICATION_SPECIFICATION);
              //Remove last generated reverse modifications as, these modifications are not saved to document
              DocumentUpdateHelper.removeListElements(reverseModifications, 0, createdReversModsNum);
              failed = true;
              break;
            }
          }

          //Import node
          Node replaceNode = doc.importNode(fragment, true);

          //Process replace
          sourceParentNode.replaceChild(replaceNode, sourceNode);

          //Merge text nodes
          sourceParentNode.normalize();
        } else if (offset != null && length != null && content != null) {
          /*
           * Replacement of part of node NOTE: Can be applied only on text node
           */

          // Checking whether node is text node
          if (sourceNode.getNodeType() != Node.TEXT_NODE) {
            if (skipNContinue) {
              // Add revers modification of failed modification to exception
              docUpdateEx.addReverseModifications(new ArrayList<TextModification>(reverseModifications.subList(0, createdReversModsNum)));
              continue;
            } else {
              docUpdateEx.setErrorMessage("Unable to apply modification on non-text node");
              docUpdateEx.setErrorCode(Localisation.ERROR_105_MODIFICATION_SPECIFICATION);
              // Remove last generated reverse modifications as, these modifications are not saved to document
              DocumentUpdateHelper.removeListElements(reverseModifications, 0, createdReversModsNum);
              failed = true;
              break;
            }
          }

          // Check whether offset is not higher than node text content length
          if (offset > sourceNode.getTextContent().length()) {
            if (skipNContinue) {
              // Add revers modification of failed modification to exception
              docUpdateEx.addReverseModifications(new ArrayList<TextModification>(reverseModifications.subList(0, createdReversModsNum)));
              continue;
            } else {
              docUpdateEx.setErrorMessage("Set modification's offset extends node text content length");
              docUpdateEx.setErrorCode(Localisation.ERROR_105_MODIFICATION_SPECIFICATION);
              // Remove last generated reverse modifications as, these modifications are not saved to document
              DocumentUpdateHelper.removeListElements(reverseModifications, 0, createdReversModsNum);
              failed = true;
              break;
            }
          }

          // Check whether offset+length is not higher than node text content length
          if (offset + length > sourceNode.getTextContent().length()) {
            if (skipNContinue) {
              // Add revers modification of failed modification to exception
              docUpdateEx.addReverseModifications(new ArrayList<TextModification>(reverseModifications.subList(0, createdReversModsNum)));
              continue;
            } else {
              docUpdateEx.setErrorMessage("Set modification's length extends node text content length");
              docUpdateEx.setErrorCode(Localisation.ERROR_105_MODIFICATION_SPECIFICATION);
              // Remove last generated reverse modifications as, these modifications are not saved to document
              DocumentUpdateHelper.removeListElements(reverseModifications, 0, createdReversModsNum);
              failed = true;
              break;
            }
          }

          /*
           * If content, that is going to take a place is empty string and it's
           * offset is set to 0 and length has the same length as source's node
           * length, will cause, that node will remain empty -> it has to be
           * removed then
           *
           * NOTE: This section should be consulted with supervisor if it's even
           * possible to achieve this state when content will be empty string If
           * there is no chance to get into this state, whole 'if' block need to
           * be removed
           */
          if (content.isEmpty() && offset == 0 && length == sourceNode.getTextContent().length()) {
            if (sourceNode.getChildNodes().getLength() < 2) {

              Node tmpNode = null;
              while (sourceNode.getChildNodes().getLength() < 2 && !sourceNode.getNodeName().equalsIgnoreCase("body")) {
                tmpNode = sourceNode;
                sourceNode = sourceNode.getParentNode();
              }
              sourceNode = tmpNode;
            }

            // Actualize parent node
            sourceParentNode = sourceNode.getParentNode();

            // Remove node
            sourceParentNode.removeChild(sourceNode);
          } else {
            // String containing prepared requested content to parse
            String tmpStr = sourceNode.getTextContent().substring(0, offset) + content + sourceNode.getTextContent().substring(offset + length);

            // Create document fragment from content of requested modification
            DocumentFragment fragment;
            try {
              fragment = matcherProvider.getFragmentFromString(tmpStr);
            } catch (Exception ex) {
              String msg = "Unable to parse fragment";
              Logger.getLogger(DocumentUpdate.class.getName()).log(Level.SEVERE, null, msg);
              if (skipNContinue) {
                // Add revers modification of failed modification to exception
                docUpdateEx.addReverseModifications(new ArrayList<TextModification>(reverseModifications.subList(0, createdReversModsNum)));
                continue;
              } else {
                docUpdateEx.setErrorMessage("Unable to parse fragment");
                docUpdateEx.setErrorCode(Localisation.ERROR_105_MODIFICATION_SPECIFICATION);
                // Remove last generated reverse modifications as, these modifications are not saved to document
                DocumentUpdateHelper.removeListElements(reverseModifications, 0, createdReversModsNum);
                failed = true;
                break;
              }
            }

            // Import node
            Node replaceNode = doc.importNode(fragment, true);

            // Process replace
            sourceParentNode.replaceChild(replaceNode, sourceNode);

            // Merge text nodes
            sourceParentNode.normalize();
          }
        }
      } else if (tm.getMode() == Constants.TEXT_MOD_INS_BEFORE) {
        /*
         * InsertBefore modification
         */
        
        Node sourceParentNode = sourceNode.getParentNode();
        if(sourceParentNode == null){
          /*
           * Element does not have its parent - insertion aborded Choose whether
           * skip&continue or interrupt modification process
           */
          if (skipNContinue) {
            // Add reverse modification of failed modification to exception
            docUpdateEx.addReverseModifications(new ArrayList<TextModification>(reverseModifications.subList(0, createdReversModsNum)));
            continue;
          } else {
            docUpdateEx.setErrorMessage("Unable to search for a parent node");
            docUpdateEx.setErrorCode(Localisation.ERROR_33_MODULE_ERROR);
            // Remove last generated reverse modifications as, these modifications are not saved to document
            DocumentUpdateHelper.removeListElements(reverseModifications, 0, createdReversModsNum);
            failed = true;
            break;
          }
        }

        //Create document fragment from content of requested modification
        DocumentFragment fragment;
        try {
          fragment = matcherProvider.getFragmentFromString(content);
        } catch (Exception ex) {
          String msg = "Unable to parse fragment";
          Logger.getLogger(DocumentUpdate.class.getName()).log(Level.SEVERE, null, msg);
          if(skipNContinue){
            // Add revers modification of failed modification to exception
            docUpdateEx.addReverseModifications(new ArrayList<TextModification>(reverseModifications.subList(0, createdReversModsNum)));
            continue;
          } else {
            docUpdateEx.setErrorMessage("Unable to parse fragment");
            docUpdateEx.setErrorCode(Localisation.ERROR_105_MODIFICATION_SPECIFICATION);
            // Remove last generated reverse modifications as, these modifications are not saved to document
            DocumentUpdateHelper.removeListElements(reverseModifications, 0, createdReversModsNum);
            failed = true;
            break;
          }
        }
        
        // Import and insertion of node
        Node insertNode = doc.importNode(fragment, true);
        sourceParentNode.insertBefore(insertNode, sourceNode);
        
        //Merge text nodes
        sourceParentNode.normalize();
      } else if (tm.getMode() == Constants.TEXT_MOD_INS_AFTER) {
        /*
         * InsertAfter modification
         */

        Node sourceParentNode = sourceNode.getParentNode();
        if (sourceParentNode == null) {
          /*
           * Element does not have its parent - insertion aborded Choose whether
           * skip&continue or interrupt modification process
           */
          if (skipNContinue) {
            // Add revers modification of failed modification to exception
            docUpdateEx.addReverseModifications(new ArrayList<TextModification>(reverseModifications.subList(0, createdReversModsNum)));
            continue;
          } else {
            docUpdateEx.setErrorMessage("Unable to search for a parent node");
            docUpdateEx.setErrorCode(Localisation.ERROR_33_MODULE_ERROR);
            // Remove last generated reverse modifications as, these modifications are not saved to document
            DocumentUpdateHelper.removeListElements(reverseModifications, 0, createdReversModsNum);
            failed = true;
            break;
          }
        }

        // Create document fragment from content of requested modification
        DocumentFragment fragment;
        try {
          fragment = matcherProvider.getFragmentFromString(content);
        } catch (Exception ex) {
          String msg = "Unable to parse fragment";
          Logger.getLogger(DocumentUpdate.class.getName()).log(Level.SEVERE, null, msg);
          if (skipNContinue) {
            // Add revers modification of failed modification to exception
            docUpdateEx.addReverseModifications(new ArrayList<TextModification>(reverseModifications.subList(0, createdReversModsNum)));
            continue;
          } else {
            docUpdateEx.setErrorMessage("Unable to parse fragment");
            docUpdateEx.setErrorCode(Localisation.ERROR_105_MODIFICATION_SPECIFICATION);
            // Remove last generated reverse modifications as, these modifications are not saved to document
            DocumentUpdateHelper.removeListElements(reverseModifications, 0, createdReversModsNum);
            failed = true;
            break;
          }
        }

        // Import node
        Node insertNode = doc.importNode(fragment, true);

        // Check, whether source node is last child
        if (sourceNode.getNextSibling() == null) {
          // Needed to append node at the end
          sourceParentNode.appendChild(insertNode);
        } else {  // There is at least one more child after this node
          // Insert node before the source's node next sibling
          sourceParentNode.insertBefore(insertNode, sourceNode.getNextSibling());
        }

        //Merge text nodes
        sourceParentNode.normalize();
      }
    }  // while (modsIt.hasNext())

    String tmp = DocumentUpdateHelper.nodeToString(doc.getDocumentElement());    
    setDocumentString(tmp);

    if (failed && !reverseRun) {
      updateDocument(true, true);
      throw docUpdateEx;
    }
  }  // updateDocument()
  
  /**
   * Method creates reversed modifications to document, that may be applied onto it in case of modification failure
   * It inserts created modification into array list passed as parameter
   *
   * @param reversedAL List of reversed modifications
   * @param modification Modification on which will be created reverse modification
   * @param sourceNode Node used in modification
   *
   * @return Number of created modifications
   *
   */
  private Integer generateReverseModifications(ArrayList<TextModification> reversedAL, TextModification modification, Node sourceNode){
    
    // Create temporary document fragment
    DocumentFragment tmpFrag = null;

    if (modification.getNewContent() != null) {
      try {
        tmpFrag = matcherProvider.getFragmentFromString(modification.getNewContent());
      } catch (Exception ex) {
        String msg = "Unable to parse fragment";
        Logger.getLogger(DocumentUpdate.class.getName()).log(Level.SEVERE, null, msg);
        docUpdateEx.setErrorCode(Localisation.ERROR_105_MODIFICATION_SPECIFICATION);
        return null;
      }
    }

    String mainXPath = modification.getPath();
    int modificationNumber = 0;
    
    if (modification.getMode() == Constants.TEXT_MOD_INS_BEFORE) {
      /*
       * Reverse to insertBefore
       */
      
      Node child = tmpFrag.getFirstChild();
      int counter = -1;
      
      /*
       * Process all fragment childs 'While loop' uses counter to correctly sort
       * reversed modifications, first has to be removed non text elements, and
       * once they will be removed, text ones can be edited
       */
      while (child != null) {
        //Increase counter of created modifications
        modificationNumber++;
        counter++;

        if (sourceNode.getNodeType() != Node.TEXT_NODE) {  // If source node is not text node
          if (child.getNodeType() != Node.TEXT_NODE) {
            String xPath = DocumentUpdateHelper.getNodePathForReversed(mainXPath, sourceNode, child.getNodeName(), Constants.TEXT_MOD_INS_BEFORE);
            TextModification tmpMod = new TextModification(xPath, null, null, null);
            reversedAL.add(0, tmpMod);
          } /*
           * As source node is not text node, it wont be merged together with
           * inserted node (in case that inserted node is text type node)
           * However, there is still posibility that inserted node will be
           * merged with source's previous sibling node
           */ else {
            if (sourceNode.getPreviousSibling() != null) {
              if (sourceNode.getPreviousSibling().getNodeType() != Node.TEXT_NODE) {
                String xPath = DocumentUpdateHelper.getNodePathForReversed(mainXPath, sourceNode, child.getNodeName(), Constants.TEXT_MOD_INS_BEFORE);
                TextModification tmpMod = new TextModification(xPath, null, null, null);
                reversedAL.add(0, tmpMod);
              } else {
                String xPath = XPathHelper.XPathStringOfNode(sourceNode.getPreviousSibling());
                TextModification tmpMod = new TextModification(xPath, sourceNode.getPreviousSibling().getTextContent().length(), child.getTextContent().length(), "");
                reversedAL.add(counter, tmpMod);
              }
            }
          }

        } else {  // If source node is text node
          // If node's type is not text, then we need to create reverse modification which will remove whole inserted element
          if(child.getNodeType() != Node.TEXT_NODE){
            String xPath = DocumentUpdateHelper.getNodePathForReversed(mainXPath, sourceNode, child.getNodeName(), Constants.TEXT_MOD_INS_BEFORE);
            TextModification tmpMod = new TextModification(xPath, null, null, null);
            reversedAL.add(0, tmpMod);
          } else {  // If node's type is text, we need to create reverse modification which will remove just inserted text
            TextModification tmpMod = new TextModification(mainXPath, 0, child.getTextContent().length(), "");
            reversedAL.add(counter, tmpMod);
          }
        }

        //Move to next child
        child = child.getNextSibling();
      }

    } else if (modification.getMode() == Constants.TEXT_MOD_INS_AFTER) {
      /*
       * Reverse to insertAfter
       */

      Node child = tmpFrag.getFirstChild();
      int counter = -1;

      /*
       * Process all fragments childs 'While loop' uses counter to correctly
       * sort reversed modifications, first has to be removed non text elements,
       * and once they will be removed, text ones can be edited
       */
      while (child != null) {
        // Increase counter of created modifications
        modificationNumber++;
        
        counter++;
        
        if (sourceNode.getNodeType() != Node.TEXT_NODE) { // If source node is not text node
          if (child.getNodeType() != Node.TEXT_NODE) {
            String xPath = DocumentUpdateHelper.getNodePathForReversed(mainXPath, sourceNode, child.getNodeName(), Constants.TEXT_MOD_INS_AFTER);
            TextModification tmpMod = new TextModification(xPath, null, null, null);
            reversedAL.add(0, tmpMod);
          } else {
            /*
             * As source node is not text node, it wont be merged together with
             * inserted node (in case that inserted node is text type node)
             * However, there is still posibility that inserted node will be
             * merged with source's next sibling node
             */

            if (sourceNode.getNextSibling() != null) {
              if (sourceNode.getNextSibling().getNodeType() != Node.TEXT_NODE) {
                String xPath = DocumentUpdateHelper.getNodePathForReversed(mainXPath, sourceNode, child.getNodeName(), Constants.TEXT_MOD_INS_AFTER);
                TextModification tmpMod = new TextModification(xPath, null, null, null);
                reversedAL.add(0, tmpMod);
              } else {
                String xPath = XPathHelper.XPathStringOfNode(sourceNode.getNextSibling());
                TextModification tmpMod = new TextModification(xPath, 0, child.getTextContent().length(), "");
                reversedAL.add(counter, tmpMod);
              }
            }
          }

        } else {  // If source node is text node
          // If node's type is not text, then we need to create reverse modification which will remove whole inserted element
          if(child.getNodeType() != Node.TEXT_NODE){
            String xPath = DocumentUpdateHelper.getNodePathForReversed(mainXPath, sourceNode, child.getNodeName(), Constants.TEXT_MOD_INS_AFTER);
            TextModification tmpMod = new TextModification(xPath, null, null, null);
            reversedAL.add(0, tmpMod);
          } else {  // If node's type is text, we need to create reverse modification which will remove just inserted text
            TextModification tmpMod = new TextModification(mainXPath, sourceNode.getTextContent().length(), child.getTextContent().length(), "");
            reversedAL.add(counter, tmpMod);
          }
        }

        // Move to next child of fragment
        child = child.getNextSibling();
      }  // while (child != null)

    } else if (modification.getMode() == Constants.TEXT_MOD_REPLACE) {
      /*
       * Reverse to replace
       */

      String content = modification.getNewContent();
      Integer offset = modification.getOffset();
      Integer length = modification.getLength();

      /*
       * Modification will remove whole node, so we need to create modification,
       * which will insert that node back to document
       */
      if (offset == null && length == null && content == null) {
        /*
         * If modification will remove whole node, the situation may arise where
         * node does not have any siblings so his parent will be automatically
         * deleted as well Therefore we need to search in "upper level" for a
         * parent node, who has at least one sibling, however maximum level is
         * at 'body' element
         */
        if (sourceNode.getChildNodes().getLength() < 2) {

          Node tmpNode = null;
          while (sourceNode.getChildNodes().getLength() < 2 && !sourceNode.getNodeName().equalsIgnoreCase("body")) {
            tmpNode = sourceNode;
            sourceNode = sourceNode.getParentNode();
          }

          sourceNode = tmpNode;
        }

        /*
         * Special case, when body after removal will remain empty without any
         * childs Reverse modificiation to this deletion has to be replacement
         * of whole body node
         */
        if (sourceNode.getParentNode().getNodeName().equalsIgnoreCase("body")
                && sourceNode.getPreviousSibling() == null && sourceNode.getNextSibling() == null) {

          String oldContent = DocumentUpdateHelper.nodeToString(sourceNode.getParentNode());
          String xPath = XPathHelper.XPathStringOfNode(sourceNode.getParentNode());

          TextModification tmpMod = new TextModification(xPath, null, null, oldContent);
          reversedAL.add(0, tmpMod);

          //Increase counter of created modifications
          modificationNumber++;
        } else if (sourceNode.getPreviousSibling() != null && sourceNode.getNextSibling() != null
                && sourceNode.getPreviousSibling().getNodeType() == Node.TEXT_NODE 
                && sourceNode.getNextSibling().getNodeType() == Node.TEXT_NODE) {
          /*
           * Once we have founded a node with sibling, generating of
           * modification can continue However, a situation may occur, when node
           * which has to be removed has previous and next sibling both of
           * text-node type After removal, those two siblings will merget
           * together, so after that, we will need to add old node back to his
           * position
           */

          String oldContent = DocumentUpdateHelper.nodeToString(sourceNode);
          String xPath = XPathHelper.XPathStringOfNode(sourceNode.getPreviousSibling());
          int newOffset = sourceNode.getPreviousSibling().getTextContent().length();

          TextModification tmpMod = new TextModification(xPath, newOffset, null, oldContent);
          reversedAL.add(0, tmpMod);

          //Increase counter of created modifications
          modificationNumber++;
        } else if (sourceNode.getPreviousSibling() != null) {
          // If node has previous sibling, we can create insertAfter modification

          //Increase counter of created modifications
          modificationNumber++;

          String oldContent = DocumentUpdateHelper.nodeToString(sourceNode);
          String xPath = XPathHelper.XPathStringOfNode(sourceNode.getPreviousSibling());
          TextModification tmpMod = new TextModification(xPath, null, null, oldContent, Constants.TEXT_MOD_INS_AFTER);
          reversedAL.add(0, tmpMod);
        } else if (sourceNode.getNextSibling() != null) {
          // In case of reversed InsertBefore we have to calculate xpath, due to changes that affect document after modification
          String xPath = "";

          //Increase counter of created modifications
          modificationNumber++;

          if (sourceNode.getNodeType() != Node.TEXT_NODE) {
            if (((Element) sourceNode).getTagName().equals(((Element) sourceNode.getNextSibling()).getTagName())) {
              xPath = DocumentUpdateHelper.getNodePathForReversed(XPathHelper.XPathStringOfNode(sourceNode.getNextSibling()), sourceNode,
                                                                  ((Element) sourceNode).getTagName(), Constants.TEXT_MOD_INS_BEFORE);
            }
          } else {
            xPath = XPathHelper.XPathStringOfNode(sourceNode.getNextSibling());
          }

          String oldContent = DocumentUpdateHelper.nodeToString(sourceNode);
          TextModification tmpMod = new TextModification(xPath, null, null, oldContent, Constants.TEXT_MOD_INS_BEFORE);
          reversedAL.add(0, tmpMod);
        }

      } else if (offset == null && length == null && content != null) {
        /*
         * Modification will replace whole node, so we need to create
         * modification, which will insert that node back to document
         */

        // Create fragment
        DocumentFragment frag = null;
        try {
          frag = matcherProvider.getFragmentFromString(content);
        } catch (Exception ex) {
          String msg = "Unable to parse fragment";
          Logger.getLogger(DocumentUpdate.class.getName()).log(Level.SEVERE, null, msg);
          docUpdateEx.setErrorCode(Localisation.ERROR_105_MODIFICATION_SPECIFICATION);
          return null;
        }

        /*
         * If content will be empty string, we need to do the same operations as
         * is done in deletion section Find a node which has at least one
         * sibling, however maximum depth can be "body" element
         */
        /*
         * FRAGMENT CONTENT IS EMPTY
         */
        if (frag.getTextContent().isEmpty()) {
          /*
           * If modification will remove whole node, the situation may arise
           * where node does not have any siblings so his parent will be
           * automatically deleted as well Therefore we need to search in "upper
           * level" for a parent node, who has at least one sibling, however
           * maximum level is at 'body' element
           */
          if (sourceNode.getChildNodes().getLength() < 2) {

            Node tmpNode = null;
            while (sourceNode.getChildNodes().getLength() < 2 && !sourceNode.getNodeName().equalsIgnoreCase("body")) {
              tmpNode = sourceNode;
              sourceNode = sourceNode.getParentNode();
            }

            sourceNode = tmpNode;
          }

          /*
           * This is a special case, when body after removal will remain empty
           * without any childs Reverse modificiation to this deletion has to be
           * replacement of whole body node
           */
          if (sourceNode.getParentNode().getNodeName().equalsIgnoreCase("body")
              && sourceNode.getPreviousSibling() == null && sourceNode.getNextSibling() == null) {

            String oldContent = DocumentUpdateHelper.nodeToString(sourceNode.getParentNode());
            String xPath = XPathHelper.XPathStringOfNode(sourceNode.getParentNode());

            TextModification tmpMod = new TextModification(xPath, null, null, oldContent);
            reversedAL.add(0, tmpMod);

            //Increase counter of created modifications
            modificationNumber++;
          } else if (sourceNode.getPreviousSibling() != null && sourceNode.getNextSibling() != null
            && sourceNode.getPreviousSibling().getNodeType() == Node.TEXT_NODE 
            && sourceNode.getNextSibling().getNodeType() == Node.TEXT_NODE){
            /*
             * Once we have founded a node with sibling, generating of
             * modification can continue However, a situation may occur, when
             * node which has to be removed has previous and next sibling both
             * of text-node type After removal, those two siblings will merget
             * together, so after that, we will need to add old node back to his
             * position
             */
            String oldContent = DocumentUpdateHelper.nodeToString(sourceNode);
            String xPath = XPathHelper.XPathStringOfNode(sourceNode.getPreviousSibling());
            int newOffset = sourceNode.getPreviousSibling().getTextContent().length();
            
            TextModification tmpMod = new TextModification(xPath, newOffset, null, oldContent);
            reversedAL.add(0, tmpMod);

            //Increase counter of created modifications
            modificationNumber++;
          } else if (sourceNode.getPreviousSibling() != null) {
            // If node has previous sibling, we can create insertAfter modification

            // Increase counter of created modifications
            modificationNumber++;

            String oldContent = DocumentUpdateHelper.nodeToString(sourceNode);
            String xPath = XPathHelper.XPathStringOfNode(sourceNode.getPreviousSibling());
            TextModification tmpMod = new TextModification(xPath, null, null, oldContent, Constants.TEXT_MOD_INS_AFTER);
            reversedAL.add(0, tmpMod);
          } else if (sourceNode.getNextSibling() != null) {
            // In case of reversed InsertBefore we have to calculate xpath, due to changes that affect document after modification
            
            String xPath = "";

            //Increase counter of created modifications
            modificationNumber++;

            if (sourceNode.getNodeType() != Node.TEXT_NODE) {
              if (((Element) sourceNode).getTagName().equals(((Element) sourceNode.getNextSibling()).getTagName())) {
                xPath = DocumentUpdateHelper.getNodePathForReversed(XPathHelper.XPathStringOfNode(sourceNode.getNextSibling()), sourceNode,
                                                                    ((Element) sourceNode).getTagName(), Constants.TEXT_MOD_INS_BEFORE);
              }
            } else {
              xPath = XPathHelper.XPathStringOfNode(sourceNode.getNextSibling());
            }

            String oldContent = DocumentUpdateHelper.nodeToString(sourceNode);
            TextModification tmpMod = new TextModification(xPath, null, null, oldContent, Constants.TEXT_MOD_INS_BEFORE);
            reversedAL.add(0, tmpMod);
          }
        } else {
          /*
           * FRAGMENT CONTENT IS NOT EMPTY
           */
          
          Node child = frag.getLastChild();
          
          if (frag.getChildNodes().getLength() == 1) {
            /*
             * If fragment has exactly one child
             */
            
            if (child.getNodeType() == Node.TEXT_NODE) {
              /*
               * If fragment has only one child and its type is TEXT, we need to
               * check whether siblings of source(replacement) node are not TEXT
               * nodes as well, due to merging of text nodes system
               */

              if (sourceNode.getPreviousSibling() != null && sourceNode.getNextSibling() != null
                  && sourceNode.getPreviousSibling().getNodeType() == Node.TEXT_NODE 
                  && sourceNode.getNextSibling().getNodeType() == Node.TEXT_NODE) {

                String oldContent = DocumentUpdateHelper.nodeToString(sourceNode);
                String xPath = XPathHelper.XPathStringOfNode(sourceNode.getPreviousSibling());
                int newOffset = sourceNode.getPreviousSibling().getTextContent().length();

                /*
                 * First create modification, that will remove the inserted
                 * text, then make modification, that will insert between those
                 * two text nodes, original node
                 */
                TextModification tmpMod = new TextModification(xPath, newOffset, null, oldContent, Constants.TEXT_MOD_REPLACE);
                reversedAL.add(0, tmpMod);

                TextModification tmpMod2 = new TextModification(xPath, newOffset, child.getTextContent().length(), "", Constants.TEXT_MOD_REPLACE);
                reversedAL.add(0, tmpMod2);

                //Increase counter of created modifications
                modificationNumber++;
              } else if (sourceNode.getPreviousSibling() != null && sourceNode.getPreviousSibling().getNodeType() == Node.TEXT_NODE){
                // If source's node previous sibling is textNode
                
                String xPath = XPathHelper.XPathStringOfNode(sourceNode.getPreviousSibling());
                int newOffset = sourceNode.getPreviousSibling().getTextContent().length();

                TextModification tmpMod = new TextModification(xPath, newOffset, child.getTextContent().length(), "", Constants.TEXT_MOD_REPLACE);
                reversedAL.add(0, tmpMod);

                modificationNumber++;
              } else if (sourceNode.getNextSibling() != null && sourceNode.getNextSibling().getNodeType() == Node.TEXT_NODE) {
                // If source's node previous sibling is textNode
                String xPath = XPathHelper.XPathStringOfNode(sourceNode.getNextSibling());

                TextModification tmpMod = new TextModification(xPath, 0, child.getTextContent().length(), "", Constants.TEXT_MOD_REPLACE);
                reversedAL.add(0, tmpMod);

                modificationNumber++;
              } else {
                // Simply replace replaced fragment
                String oldContent = DocumentUpdateHelper.nodeToString(sourceNode);
                String xPath = DocumentUpdateHelper.getNodePathForReversed(mainXPath, sourceNode, child.getNodeName(), Constants.TEXT_MOD_REPLACE);

                TextModification tmpMod = new TextModification(xPath, null, null, oldContent, Constants.TEXT_MOD_REPLACE);
                reversedAL.add(0, tmpMod);
                modificationNumber++;
              }
            } else {
              // Simply replace replaced fragment

              String oldContent = DocumentUpdateHelper.nodeToString(sourceNode);
              String xPath = DocumentUpdateHelper.getNodePathForReversed(mainXPath, sourceNode, child.getNodeName(), Constants.TEXT_MOD_REPLACE);

              TextModification tmpMod = new TextModification(xPath, null, null, oldContent, Constants.TEXT_MOD_REPLACE);
              reversedAL.add(0, tmpMod);
              modificationNumber++;
            }
          } else if (frag.getChildNodes().getLength() == 2) {
            /*
             * If fragment has exactly two childs
             */

            Node child1 = frag.getFirstChild();
            Node child2 = frag.getLastChild();
            if (frag.getFirstChild().getNodeType() == Node.TEXT_NODE) {
              // If first child is text node
              
              // Check whether source previous sibling is text node
              if (sourceNode.getPreviousSibling() != null && sourceNode.getPreviousSibling().getNodeType() == Node.TEXT_NODE) {
                String xPath = XPathHelper.XPathStringOfNode(sourceNode.getPreviousSibling());
                int newOffset = sourceNode.getPreviousSibling().getTextContent().length();

                TextModification tmpMod = new TextModification(xPath, newOffset, child1.getTextContent().length(), "", Constants.TEXT_MOD_REPLACE);
                reversedAL.add(0, tmpMod);

                modificationNumber++;
              } else {  // Remove first inserted child
                String xPath = DocumentUpdateHelper.getNodePathForReversed(mainXPath, sourceNode, child1.getNodeName(), Constants.TEXT_MOD_REPLACE);
                TextModification tmpMod = new TextModification(xPath, null, null, null, Constants.TEXT_MOD_REPLACE);
                reversedAL.add(0, tmpMod);
                modificationNumber++;
              }
              // Replace seconds inserted child node with original content
              String oldContent = DocumentUpdateHelper.nodeToString(sourceNode);
              String xPath = DocumentUpdateHelper.getNodePathForReversed(mainXPath, sourceNode, child2.getNodeName(), Constants.TEXT_MOD_REPLACE);
              
              // NOTE: INSERTING MODIFICATION AT 2ND PLACE IN LIST, BECAUSE FIRST HAS TO BE DELETED FIRST CHILD
              TextModification tmpMod = new TextModification(xPath, null, null, oldContent, Constants.TEXT_MOD_REPLACE);
              reversedAL.add(1, tmpMod);
              modificationNumber++;
            } else if (frag.getLastChild().getNodeType() == Node.TEXT_NODE) {
              // If second(last) child is text node

              // Check whether source next sibling is text node
              if(sourceNode.getNextSibling() != null && sourceNode.getNextSibling().getNodeType() == Node.TEXT_NODE){
                String xPath = XPathHelper.XPathStringOfNode(sourceNode.getNextSibling());

                TextModification tmpMod = new TextModification(xPath, 0, child.getTextContent().length(), "", Constants.TEXT_MOD_REPLACE);
                reversedAL.add(0, tmpMod);

                modificationNumber++;
              }
              // Remove second inserted child
              else{
                String xPath = DocumentUpdateHelper.getNodePathForReversed(mainXPath, sourceNode, child2.getNodeName(), Constants.TEXT_MOD_REPLACE);
                TextModification tmpMod = new TextModification(xPath, null, null, null, Constants.TEXT_MOD_REPLACE);

                reversedAL.add(0, tmpMod);

                modificationNumber++;
              }

              // Replace first inserted child node with original content
              String oldContent = DocumentUpdateHelper.nodeToString(sourceNode);
              String xPath = DocumentUpdateHelper.getNodePathForReversed(mainXPath, sourceNode, child1.getNodeName(), Constants.TEXT_MOD_REPLACE);
              // NOTE: INSERTING MODIFICATION AT 2ND PLACE IN LIST, BECAUSE FIRST HAS TO BE DELETED FIRST CHILD
              TextModification tmpMod = new TextModification(xPath, null, null, oldContent, Constants.TEXT_MOD_REPLACE);
              
              reversedAL.add(1, tmpMod);
              modificationNumber++;
            } else {
              // Simple remove one child and next one will be replaced back to document's original content
              
              String xPath1 = DocumentUpdateHelper.getNodePathForReversed(mainXPath, sourceNode, child1.getNodeName(), Constants.TEXT_MOD_REPLACE);
              String xPath2 = DocumentUpdateHelper.getNodePathForReversed(mainXPath, sourceNode, child2.getNodeName(), Constants.TEXT_MOD_REPLACE);
              String oldContent = DocumentUpdateHelper.nodeToString(sourceNode);

              TextModification tmpMod = new TextModification(xPath1, null, null, null, Constants.TEXT_MOD_REPLACE);
              TextModification tmpMod2 = new TextModification(xPath2, null, null, oldContent, Constants.TEXT_MOD_REPLACE);

              reversedAL.add(0, tmpMod2);
              reversedAL.add(0, tmpMod);

              modificationNumber++;
              modificationNumber++;
            }

          } else {
            /*
             * If fragment has three or more childs
             */
            
            ArrayList<TextModification> stack = new ArrayList<TextModification>();
            /*
             * If fragment has at least two childs:
             *      If child is first one and its type is text node we need to check whether previous source(replacement) node sibling is not 
             *      text node either - they will be merged together
             */
            while (child != null) {
              /*
               * If child is first one and it's type is text node, and souce's
               * previous sibling's type is text node as well we need to remove
               * part of inserted text, as those two elements will be
               * automatically merged together
               */
              
              if (child.getPreviousSibling() == null && sourceNode.getPreviousSibling() != null
                  && sourceNode.getPreviousSibling().getNodeType() == Node.TEXT_NODE && child.getNodeType() == Node.TEXT_NODE) {

                String oldContent = DocumentUpdateHelper.nodeToString(sourceNode);
                String xPath = XPathHelper.XPathStringOfNode(sourceNode.getPreviousSibling());
                int newOffset = sourceNode.getPreviousSibling().getTextContent().length();

                TextModification tmpMod = new TextModification(xPath, newOffset, child.getTextContent().length(), "", Constants.TEXT_MOD_REPLACE);
                reversedAL.add(0, tmpMod);
              } else if (child.getNextSibling() != null && child.getNextSibling().getNextSibling() == null) {
                /*
                 * If child is penultimate, here comes replacement process
                 */
                
                String oldContent = DocumentUpdateHelper.nodeToString(sourceNode);
                String xPath = DocumentUpdateHelper.getNodePathForReversed(mainXPath, sourceNode, child.getNodeName(), Constants.TEXT_MOD_REPLACE);

                TextModification tmpMod = new TextModification(xPath, null, null, oldContent, Constants.TEXT_MOD_REPLACE);
                reversedAL.add(0, tmpMod);
              } else if (child.getNextSibling() == null && sourceNode.getNextSibling() != null
                         && sourceNode.getNextSibling().getNodeType() == Node.TEXT_NODE && child.getNodeType() == Node.TEXT_NODE) {
                /*
                 * If type of last child is text, and next sibling of
                 * source(replace) node is text type as well we need to remove
                 * part of inserted text, as those two elements will be
                 * automatically merged together
                 */

                String xPath = XPathHelper.XPathStringOfNode(sourceNode.getNextSibling());
                int newLength = child.getTextContent().length();

                TextModification tmpMod = new TextModification(xPath, 0, newLength, "", Constants.TEXT_MOD_REPLACE);
                reversedAL.add(0, tmpMod);
              } else if (child.getNextSibling() == null) {
                /*
                 * If child is last one and his type is not Text
                 */

                String oldContent = DocumentUpdateHelper.nodeToString(sourceNode);
                String xPath = DocumentUpdateHelper.getNodePathForReversed(mainXPath, sourceNode, child.getNodeName(), Constants.TEXT_MOD_REPLACE);

                TextModification tmpMod = new TextModification(xPath, null, null, oldContent, Constants.TEXT_MOD_REPLACE);
                reversedAL.add(0, tmpMod);
              } else {
                /*
                 * All elements between first and last will be simply deleted
                 */

                String xPath = DocumentUpdateHelper.getNodePathForReversed(mainXPath, sourceNode, child.getNodeName(), Constants.TEXT_MOD_REPLACE);

                TextModification tmpMod = new TextModification(xPath, null, null, null, Constants.TEXT_MOD_REPLACE);
                if(child.getNodeType() == Node.TEXT_NODE){
                  stack.add(0, tmpMod);
                } else {
                  reversedAL.add(0, tmpMod);
                }
              }
              // Increase counter of created modifications
              modificationNumber++;

              child = child.getPreviousSibling();

            }

            reversedAL.addAll(0, stack);
          }
        }
      } else if (offset != null && length == null && content != null) {
        /*
         * Modification will make insertion new content into node, so all
         * inserted content need to be removed NOTE: Can be applied only on text
         * node
         */
     
        Node child = tmpFrag.getFirstChild();
        int counter = -1;

        while (child != null) {
          // Increase counter of created modifications
          modificationNumber++;

          counter++;
          if (child.getNodeType() != Node.TEXT_NODE) {
            String xPath = DocumentUpdateHelper.getNodePathForReversed(mainXPath, sourceNode, child.getNodeName(), Constants.TEXT_MOD_REPLACE);
            TextModification tmpMod = new TextModification(xPath, null, null, null);
            reversedAL.add(0, tmpMod);
          } else {
            TextModification tmpMod = new TextModification(mainXPath, offset, child.getTextContent().length(), "");
            reversedAL.add(counter, tmpMod);
          }
          //Move to next child of fragment
          child = child.getNextSibling();
        }

      } else if (offset != null && length != null && content != null) {
        /*
         * Modification will replace of part of node, so it's needed to remove
         * all replaced nodes and insert back part of old one NOTE: Can be
         * applied only on text node
         */

        Node child = tmpFrag.getFirstChild();
        int counter = -1;

        /*
         * If content, that is going to take a place is empty string and it's
         * offset is set to 0 and length has the same length as source's node
         * length, will cause, that node will remain empty -> it has to be
         * removed then
         *
         * NOTE: This section should be consulted with supervisor if it's even
         * possible to achieve this state when content will be empty string If
         * there is no chance to get into this state, whole 'if' block need to
         * be removed
         */
        if (content.isEmpty() && offset == 0 && length == sourceNode.getTextContent().length()) {
          /*
           * If modification will remove whole node, the situation may arise
           * where node does not have any siblings so his parent will be
           * automatically deleted as well Therefore we need to search in "upper
           * level" for a parent node, who has at least one sibling, however
           * maximum level is at 'body' element
           */
          if (sourceNode.getChildNodes().getLength() < 2) {

            Node tmpNode = null;
            while (sourceNode.getChildNodes().getLength() < 2 && !sourceNode.getNodeName().equalsIgnoreCase("body")) {
              tmpNode = sourceNode;
              sourceNode = sourceNode.getParentNode();
            }

            sourceNode = tmpNode;
          }

          /*
           * Special case, when body after removal will remain empty without any
           * childs Reverse modificiation to this deletion has to be replacement
           * of whole body node
           */
          if (sourceNode.getParentNode().getNodeName().equalsIgnoreCase("body")
              && sourceNode.getPreviousSibling() == null && sourceNode.getNextSibling() == null) {

            String oldContent = DocumentUpdateHelper.nodeToString(sourceNode.getParentNode());
            String xPath = XPathHelper.XPathStringOfNode(sourceNode.getParentNode());

            TextModification tmpMod = new TextModification(xPath, null, null, oldContent);
            reversedAL.add(0, tmpMod);

            //Increase counter of created modifications
            modificationNumber++;
          } else if (sourceNode.getPreviousSibling() != null && sourceNode.getNextSibling() != null
                     && sourceNode.getPreviousSibling().getNodeType() == Node.TEXT_NODE
                     && sourceNode.getNextSibling().getNodeType() == Node.TEXT_NODE) {
            /*
             * Once we have founded a node with sibling, generating of
             * modification can continue However, a situation may occur, when
             * node which has to be removed has previous and next sibling both
             * of text-node type After removal, those two siblings will merget
             * together, so after that, we will need to add old node back to his
             * position
             */

            String oldContent = DocumentUpdateHelper.nodeToString(sourceNode);
            String xPath = XPathHelper.XPathStringOfNode(sourceNode.getPreviousSibling());
            int newOffset = sourceNode.getPreviousSibling().getTextContent().length();
            
            TextModification tmpMod = new TextModification(xPath, newOffset, null, oldContent);
            reversedAL.add(0, tmpMod);

            // Increase counter of created modifications
            modificationNumber++;
          } else if (sourceNode.getPreviousSibling() != null) {
            // If node has previous sibling, we can create insertAfter modification

            // Increase counter of created modifications
            modificationNumber++;

            String oldContent = DocumentUpdateHelper.nodeToString(sourceNode);
            String xPath = XPathHelper.XPathStringOfNode(sourceNode.getPreviousSibling());
            TextModification tmpMod = new TextModification(xPath, null, null, oldContent, Constants.TEXT_MOD_INS_AFTER);
            reversedAL.add(0, tmpMod);
          } else if (sourceNode.getNextSibling() != null) {
            // In case of reversed InsertBefore we have to calculate xpath, due to changes that affect document after modification

            String xPath = "";

            //Increase counter of created modifications
            modificationNumber++;

            if (sourceNode.getNodeType() != Node.TEXT_NODE) {
              if (((Element) sourceNode).getTagName().equals(((Element) sourceNode.getNextSibling()).getTagName())) {
                xPath = DocumentUpdateHelper.getNodePathForReversed(XPathHelper.XPathStringOfNode(sourceNode.getNextSibling()), sourceNode,
                        ((Element) sourceNode).getTagName(), Constants.TEXT_MOD_INS_BEFORE);
              }
            } else {
              xPath = XPathHelper.XPathStringOfNode(sourceNode.getNextSibling());
            }

            String oldContent = DocumentUpdateHelper.nodeToString(sourceNode);
            TextModification tmpMod = new TextModification(xPath, null, null, oldContent, Constants.TEXT_MOD_INS_BEFORE);
            reversedAL.add(0, tmpMod);
          }
        } else {
          // Get content which will be overwritten by modification
          String overContent = sourceNode.getTextContent().substring(offset, offset + length);

          while (child != null) {
            //Increase counter of created modifications
            modificationNumber++;
            counter++;


            if (child.getNodeType() != Node.TEXT_NODE) {
              String xPath = DocumentUpdateHelper.getNodePathForReversed(mainXPath, sourceNode, child.getNodeName(), Constants.TEXT_MOD_REPLACE);
              TextModification tmpMod = new TextModification(xPath, null, null, null);
              reversedAL.add(0, tmpMod);
            } else {
              TextModification tmpMod = new TextModification(mainXPath, offset, child.getTextContent().length(), "");
              reversedAL.add(counter, tmpMod);
            }
            // Move to next child of fragment
            child = child.getNextSibling();
          }
          counter++;

          // Last reverse modification has to be insertion of original content back to its node
          TextModification tmpMod = new TextModification(mainXPath, offset, null, overContent);
          reversedAL.add(counter, tmpMod);
        }
      }  // Modification will replace of part of node ...
    }  // modification.getMode() == Constants.TEXT_MOD_REPLACE
    return modificationNumber;
  }  // generateReverseModifications()
}  // public class DocumentUpdate