platform/util/src/com/intellij/openapi/diff/impl/fragments/LineFragment.java

/*
 * Copyright 2000-2013 JetBrains s.r.o.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.intellij.openapi.diff.impl.fragments;

import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.diff.impl.string.DiffString;
import com.intellij.openapi.diff.impl.highlighting.FragmentSide;
import com.intellij.openapi.diff.impl.util.TextDiffTypeEnum;
import com.intellij.openapi.util.Condition;
import com.intellij.openapi.util.TextRange;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

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

public class LineFragment extends LineBlock implements Fragment {
  private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.diff.impl.fragments.LineFragment");
  private final TextRange myRange1;
  private final TextRange myRange2;
  private FragmentList myChildren;
  private boolean myHasLineChildren;

  public LineFragment(int startingLine1, int modifiedLines1,
                      int startingLine2, int modifiedLines2,
                      TextDiffTypeEnum blockType, TextRange range1, TextRange range2) {
    this(startingLine1, modifiedLines1,
         startingLine2, modifiedLines2,
         blockType, range1, range2, FragmentList.EMPTY);
  }

  private LineFragment(int startingLine1, int modifiedLines1,
                       int startingLine2, int modifiedLines2,
                       TextDiffTypeEnum blockType, TextRange range1, TextRange range2, FragmentList children) {
    super(startingLine1, modifiedLines1, startingLine2, modifiedLines2, blockType);
    LOG.assertTrue(modifiedLines1 > 0 || modifiedLines2 > 0);
    myRange1 = range1;
    myRange2 = range2;
    myChildren = children;
    checkChildren(myChildren.iterator());
  }


  @Override
  public TextRange getRange(FragmentSide side) {
    if (side == FragmentSide.SIDE1) return myRange1;
    if (side == FragmentSide.SIDE2) return myRange2;
    throw new IllegalArgumentException(String.valueOf(side));
  }

  @Override
  public Fragment shift(TextRange range1, TextRange range2, int startingLine1, int startingLine2) {
    return new LineFragment(startingLine1 + getStartingLine1(), getModifiedLines1(),
                            startingLine2 + getStartingLine2(), getModifiedLines2(),
                            getType(), shiftRange(range1, myRange1), shiftRange(range2, myRange2),
                            myChildren.shift(range1, range2, startingLine1, startingLine2));
  }

  /**
   * <p>Adjusts the diff type of this line fragment based on the types of the inline child fragments.</p>
   * <p>For example, a modification in terms of line fragment may be just one inline insertion.
   * In this case it is better to think about the whole change as of insertion.</p>
   */
  public void adjustTypeFromChildrenTypes() {
    if (getType() != TextDiffTypeEnum.CHANGED) { // if the change is already insertion or deletion, no need to adjust
      return;
    }

    TextDiffTypeEnum candidateType = null;
    for (Iterator<Fragment> children = getChildrenIterator(); children != null && children.hasNext(); ) {
      TextDiffTypeEnum fragmentType = children.next().getType();
      if (fragmentType == null) {
        continue;
      }
      switch (fragmentType) {
        case CHANGED: // inline change => everything is a change
          return;
        case INSERT:
          if (candidateType == null) {
            candidateType = TextDiffTypeEnum.INSERT;
          }
          else if (candidateType != TextDiffTypeEnum.INSERT) {
            return; // different changes (insertion and deletion) inside a single line => everything is a change
          }
          break;
        case DELETED:
          if (candidateType == null) {
            candidateType = TextDiffTypeEnum.DELETED;
          }
          else if (candidateType != TextDiffTypeEnum.DELETED) {
            return;
          }
          break;
        default:
          // should not happen, because conflicts can happen only in merge tools, where there are no inline changes for now,
          // but we don't want to modify the fragment in this doubtful case anyway.
          return;
      }
    }

    if (candidateType != null) {
      setType(candidateType);
    }
  }

  static TextRange shiftRange(TextRange shift, TextRange range) {
    int start = shift.getStartOffset();
    int newEnd = start + range.getEndOffset();
    int newStart = start + range.getStartOffset();
    LOG.assertTrue(newStart <= shift.getEndOffset());
    LOG.assertTrue(newEnd <= shift.getEndOffset());
    return new TextRange(newStart, newEnd);
  }

  @Override
  public void highlight(FragmentHighlighter fragmentHighlighter) {
    fragmentHighlighter.highlightLine(this);
  }

  public boolean isOneSide() {
    return myRange1.getLength() == 0 || myRange2.getLength() == 0;
  }

  public boolean isEqual() {
    return getType() == null;
  }

  @Override
  public Fragment getSubfragmentAt(int offset, FragmentSide side, Condition<Fragment> condition) {
    Fragment childFragment = myChildren.getFragmentAt(offset, side, condition);
    return childFragment != null ? childFragment : this;
  }

  @Nullable
  public Iterator<Fragment> getChildrenIterator() {
    return myChildren == null || myChildren.isEmpty() ? null : myChildren.iterator();
  }

  @NotNull
  public DiffString getText(@NotNull DiffString text, @NotNull FragmentSide side) {
    TextRange range = getRange(side);
    return text.substring(range.getStartOffset(), range.getEndOffset());
  }


  public void addAllDescendantsTo(ArrayList<LineFragment> descendants) {
    if (myChildren == null) return;
    for (Iterator<Fragment> iterator = myChildren.iterator(); iterator.hasNext();) {
      Fragment fragment = iterator.next();
      if (fragment instanceof LineFragment) {
        LineFragment lineFragment = (LineFragment)fragment;
        descendants.add(lineFragment);
        lineFragment.addAllDescendantsTo(descendants);
      }
    }
  }

  public void setChildren(ArrayList<Fragment> fragments) {
    LOG.assertTrue(myChildren == FragmentList.EMPTY);
    ArrayList<Fragment> shifted =
        FragmentListImpl.shift(fragments, myRange1, myRange2, getStartingLine1(), getStartingLine2());
    if (shifted.isEmpty()) return;
    Fragment firstChild = shifted.get(0);
    if (shifted.size() == 1 && isSameRanges(firstChild)) {
      if (!(firstChild instanceof LineFragment)) return;
      LineFragment lineFragment = (LineFragment)firstChild;
      myChildren = lineFragment.myChildren;
    } else myChildren = FragmentListImpl.fromList(shifted);
    checkChildren(myChildren.iterator());
  }

  private void checkChildren(Iterator<Fragment> iterator) {
    if (myChildren.isEmpty()) {
      myHasLineChildren = false;
      return;
    }
    boolean hasLineChildren = false;
    boolean hasInlineChildren = false;
    while(iterator.hasNext()) {
      Fragment fragment = iterator.next();
      boolean lineChild = fragment instanceof LineFragment;
      hasLineChildren |= lineChild;
      hasInlineChildren |= !lineChild;
      if (lineChild) {
        LineFragment lineFragment = (LineFragment)fragment;
        LOG.assertTrue(getStartingLine1() != lineFragment.getStartingLine1() ||
                       getModifiedLines1() != lineFragment.getModifiedLines1() ||
                       getStartingLine2() != lineFragment.getStartingLine2() ||
                       getModifiedLines2() != lineFragment.getModifiedLines2());
      }
    }
    LOG.assertTrue(hasLineChildren ^ hasInlineChildren);
    myHasLineChildren = hasLineChildren;
  }

  private boolean isSameRanges(Fragment fragment) {
    return getRange(FragmentSide.SIDE1).equals(fragment.getRange(FragmentSide.SIDE1)) &&
           getRange(FragmentSide.SIDE2).equals(fragment.getRange(FragmentSide.SIDE2));
  }

  public boolean isHasLineChildren() {
    return myHasLineChildren;
  }

  @Override
  public int getEndLine1() {
    return super.getEndLine1();
  }

  @Override
  public int getEndLine2() {
    return super.getEndLine2();
  }
}