コード例 #1
0
 /**
  * Creates the nested delta deltas based on the affected element its delta, and the root of this
  * delta tree. Returns the root of the created delta tree.
  */
 @SuppressWarnings("unchecked")
 protected ModelElementDelta createDeltaTree(IModelElement element, ModelElementDelta delta) {
   ModelElementDelta childDelta = delta;
   ArrayList ancestors = getAncestors(element);
   if (ancestors == null) {
     if (this.equalsAndSameParent(
         delta.getElement(),
         getElement())) { // handle case of two archives that can be equals but not in the same
       // project
       // the element being changed is the root element
       this.kind = delta.kind;
       this.changeFlags = delta.changeFlags;
       this.movedToHandle = delta.movedToHandle;
       this.movedFromHandle = delta.movedFromHandle;
     }
   } else {
     for (int i = 0, size = ancestors.size(); i < size; i++) {
       IModelElement ancestor = (IModelElement) ancestors.get(i);
       ModelElementDelta ancestorDelta = new ModelElementDelta(ancestor);
       ancestorDelta.addAffectedChild(childDelta);
       childDelta = ancestorDelta;
     }
   }
   return childDelta;
 }
コード例 #2
0
 /**
  * Creates the delta tree for the given element and delta, and then inserts the tree as an
  * affected child of this node.
  */
 protected void insertDeltaTree(IModelElement element, ModelElementDelta delta) {
   ModelElementDelta childDelta = createDeltaTree(element, delta);
   if (!this.equalsAndSameParent(
       element,
       getElement())) { // handle case of two archives that can be equals but not in the same
     // project
     addAffectedChild(childDelta);
   }
 }
コード例 #3
0
  /**
   * Adds the child delta to the collection of affected children. If the child is already in the
   * collection, walk down the hierarchy.
   */
  protected void addAffectedChild(ModelElementDelta child) {
    switch (this.kind) {
      case ADDED:
      case REMOVED:
        // no need to add a child if this parent is added or removed
        return;
      case CHANGED:
        this.changeFlags |= F_CHILDREN;
        break;
      default:
        this.kind = CHANGED;
        this.changeFlags |= F_CHILDREN;
    }

    // if a child delta is added to a compilation unit delta or below,
    // it's a fine grained delta
    if (this.changedElement.getElementType() >= IModelElement.MODULE) {
      this.fineGrained();
    }

    if (this.affectedChildren == null || this.affectedChildren.length == 0) {
      this.affectedChildren = new IModelElementDelta[] {child};
      return;
    }
    ModelElementDelta existingChild = null;
    int existingChildIndex = -1;
    if (this.affectedChildren != null) {
      for (int i = 0; i < this.affectedChildren.length; i++) {
        if (this.equalsAndSameParent(
            this.affectedChildren[i].getElement(),
            child.getElement())) { // handle case of two archives that can be equals but not in the
          // same project
          existingChild = (ModelElementDelta) this.affectedChildren[i];
          existingChildIndex = i;
          break;
        }
      }
    }
    if (existingChild == null) { // new affected child
      this.affectedChildren = growAndAddToArray(this.affectedChildren, child);
    } else {
      switch (existingChild.getKind()) {
        case ADDED:
          switch (child.getKind()) {
            case ADDED: // child was added then added -> it is added
            case CHANGED: // child was added then changed -> it is added
              return;
            case REMOVED: // child was added then removed -> noop
              this.affectedChildren =
                  this.removeAndShrinkArray(this.affectedChildren, existingChildIndex);
              return;
          }
          break;
        case REMOVED:
          switch (child.getKind()) {
            case ADDED: // child was removed then added -> it is changed
              child.kind = CHANGED;
              this.affectedChildren[existingChildIndex] = child;
              return;
            case CHANGED: // child was removed then changed -> it is removed
            case REMOVED: // child was removed then removed -> it is removed
              return;
          }
          break;
        case CHANGED:
          switch (child.getKind()) {
            case ADDED: // child was changed then added -> it is added
            case REMOVED: // child was changed then removed -> it is removed
              this.affectedChildren[existingChildIndex] = child;
              return;
            case CHANGED: // child was changed then changed -> it is changed
              IModelElementDelta[] children = child.getAffectedChildren();
              for (int i = 0; i < children.length; i++) {
                ModelElementDelta childsChild = (ModelElementDelta) children[i];
                existingChild.addAffectedChild(childsChild);
              }

              // update flags
              boolean childHadContentFlag = (child.changeFlags & F_CONTENT) != 0;
              boolean existingChildHadChildrenFlag = (existingChild.changeFlags & F_CHILDREN) != 0;
              existingChild.changeFlags |= child.changeFlags;

              // remove F_CONTENT flag if existing child had F_CHILDREN flag set
              // (case of fine grained delta (existing child) and delta coming from
              // DeltaProcessor (child))
              if (childHadContentFlag && existingChildHadChildrenFlag) {
                existingChild.changeFlags &= ~F_CONTENT;
              }

              // add the non-java resource deltas if needed
              // note that the child delta always takes precedence over this existing child delta
              // as non-java resource deltas are always created last (by the DeltaProcessor)
              IResourceDelta[] resDeltas = child.getResourceDeltas();
              if (resDeltas != null) {
                existingChild.resourceDeltas = resDeltas;
                existingChild.resourceDeltasCounter = child.resourceDeltasCounter;
              }

              return;
          }
          break;
        default:
          // unknown -> existing child becomes the child with the existing child's flags
          int flags = existingChild.getFlags();
          this.affectedChildren[existingChildIndex] = child;
          child.changeFlags |= flags;
      }
    }
  }