LastTextModifications.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Bc. Lukáš Kubík
 * File: LastTextModifications.java
 * Description: Class representing last 3 applied modification sets on a document
 */

/**
 * @file LastTextModifications.java
 *
 * @brief Class representing last 3 applied modification sets on a document
 */

package cz.vutbr.fit.knot.annotations.app;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * Class representing last 3 applied modification sets on a document
 *
 * @brief Class representing last applied modifications on a document
 * @author xkubik22
 */
public class LastTextModifications {
  
  /** 
   * ID of the affected document 
   */
  private Integer documentID = null;
  
  /**
   * List of applied modification set ID's
   */
  private ArrayList<Integer> modificationsID = new ArrayList<Integer>();
  
  /**
   * List of applied modification sets
   */
  private ArrayList<ArrayList<TextModification>> appliedModifications = new ArrayList<ArrayList<TextModification>>();
  
  /**
   * Empty constructor
   */
  public LastTextModifications(){ 
    
  }
  
  /**
   * Constructor for first applied modifications
   * 
   * @param documentID id of the changed document
   * @param firstModificationID first modification set ID
   * @param firstModifications first modification set
   */
  public LastTextModifications(int documentID, int firstModificationID, ArrayList<TextModification> firstModifications){
    this.documentID = documentID;
    this.modificationsID.add(firstModificationID);
    this.appliedModifications.add(firstModifications);
  }
  
  /**
   * Adds next applied modification
   * If are there already three modifications then it deletes the oldest one.
   * 
   * @param modificationID modification set ID
   * @param modifications modification set
   */
  public synchronized void addNextModificationSet(int modificationID, ArrayList<TextModification> modifications){
    this.appliedModifications.add(modifications);
    this.modificationsID.add(modificationID);
    if(appliedModifications.size() > 3){
      this.appliedModifications.remove(0);
      this.modificationsID.remove(0);
    }
  }
  
  /**
   * Checks whetever last modification sets contains passed ID
   * 
   * @param modificationID modification set ID
   */
  public synchronized boolean containsSet(int modificationID){
    return this.modificationsID.contains(modificationID);
  }
  
  
  /**
   * Checks whetever the modification sets applied after modification
   * identified by the passed setID contains conflicts with passed modification set.
   * 
   * @param setID ID of the set preceding the checked sets
   * @param modifications Checked modification set
   * @return true if are there conflicts otherwise false
   */
  public synchronized boolean hasModificationSetsConflicts(int setID,
          ArrayList<TextModification> modifications)
  {
    if(modifications.isEmpty()){
      return false;
    }
    int modIndex = this.modificationsID.indexOf(setID);
    if(modIndex > -1){
      ++modIndex;
      for(int i = modIndex; i < this.modificationsID.size(); i++){
        if(compareTwoSetsForConflicts(modifications, this.appliedModifications.get(i))){
          return true;
        }
      }
    }
    return false;
  }
  
  /**
   * Compares two modification sets for conflicts
   * firstModSet should be applied before secondModSet.
   * Checks for compatibility.
   * 
   * @param firstModSet First modification set
   * @param secondModSet Second modification set
   * @return true if is there some conflict otherwise false
   */
  private synchronized boolean compareTwoSetsForConflicts(ArrayList<TextModification> firstModSet,
          ArrayList<TextModification> secondModSet)
  {
    Iterator<TextModification> firstIT = firstModSet.iterator();
    while(firstIT.hasNext()){
      TextModification firstMod = firstIT.next();
      Iterator<TextModification> secondIT = secondModSet.iterator();
      while(secondIT.hasNext()){
        TextModification secondMod = secondIT.next();
        if(compareTwoModsForConflicts(firstMod, secondMod)){
          return true;
        }
      }
    }
    return false;
  }
  
  /**
   * Compares two modifications for conflicts
   * firstMod should be applied before secondMod.
   * Checks for compatibility.
   * 
   * @param firstMod First modification
   * @param secondMod Second modification
   * @return true if is there some conflict otherwise false
   */
  private synchronized boolean compareTwoModsForConflicts(TextModification firstMod,
          TextModification secondMod)
  {
    /** Replace options:
     * Replacement of whole node (0 - n xpath change)
       Delete whole node (1 xpath change)
       Insertion to node (only change of the content of the node)
       Replacement of part of node (only change of the content of the node)
     */
    int pathComp = (firstMod.getPath() + "z").compareTo(secondMod.getPath() + "z");
    switch(firstMod.getMode()){
      case Constants.TEXT_MOD_REPLACE:
        switch(secondMod.getMode()){
          case Constants.TEXT_MOD_REPLACE://done
            // same node
            if(pathComp == 0){
              return true;
            }
            // first node is before second node xpath
            else if(pathComp < 0){
              //delete or replace first == conflict
              //otherwise false
              if(firstMod.getOffset() == null && firstMod.getLength() == null){
                return true;
              }
            }
            break;          
          case Constants.TEXT_MOD_INS_BEFORE://done
            // first is before second
            if(pathComp < 0){
              //delete or replace first == conflict
              //otherwise false
              if(firstMod.getOffset() == null && firstMod.getLength() == null){
                return true;
              }
            }
            //first = delete the same node
            else if(pathComp == 0 && firstMod.getOffset() == null && 
                    firstMod.getLength() == null && firstMod.getNewContent() == null)
            {
              return true;
            }
            break;
          case Constants.TEXT_MOD_INS_AFTER:
            // first is before second or the same node
            if(pathComp <= 0){
              //delete or replace first == conflict
              //otherwise false
              if(firstMod.getOffset() == null && firstMod.getLength() == null){
                return true;
              }
            }
            break;
        }
        break;
      case Constants.TEXT_MOD_INS_BEFORE:
        // first is before second or the same node
        if(pathComp <= 0){
            return true;
        }
        break;
      case Constants.TEXT_MOD_INS_AFTER:
        switch(secondMod.getMode()){
          case Constants.TEXT_MOD_REPLACE:
          case Constants.TEXT_MOD_INS_BEFORE:
            // first is before second
            if(pathComp < 0){
                return true;
            }
            break;
          case Constants.TEXT_MOD_INS_AFTER:
            // first is before second or the same node
            if(pathComp <= 0){
                return true;
            }
            break;
        }
        break;
    }
    return false;
  }

}  // public class LastTextModifications