Compares the read counts.
@param other read count
@return results
186919
private int compareToLFU( CacheEntry other ) {

        int cmp = compareReadCount( other );
        if ( cmp != 0 ) {
            return cmp;
        }

        cmp = compareTime( other );
        if ( cmp != 0 ) {
            return cmp;
        }

        return compareOrder( other );
    }
1352791
@Override
    public int compareTo(final MutableChar other) {
        return (this.value > other.value) ? 1 : ((this.value == other.value) ? 0 : -1);
    }
1001355
public synchronized void incrAllCounters(Counters other) {
    for (Group otherGroup: other) {
      Group group = getGroup(otherGroup.getName());
      group.displayName = otherGroup.displayName;
      for (Counter otherCounter : otherGroup) {
        Counter counter = group.getCounterForName(otherCounter.getName());
        counter.setDisplayName(otherCounter.getDisplayName());
        counter.increment(otherCounter.getValue());
      }
    }
  }
900322
@Override
    public int compareTo(ClassHash other) {
        int cmp = MethodHash.compareHashes(this.classHash, other.classHash);
        // System.out.println(this + " <=> " + other + ": compareTo=" + cmp);
        return cmp;
    }
60971
public int compareSwappedTo(IntIntPair other) {
    int fdiff = this.second - other.second;
    if(fdiff != 0) {
      return fdiff;
    }
    return this.first - other.first;
  }
1002941
public boolean overlapsWith(IndexRange other) {
        checkArgNotNull(other, "other");
        return end > other.start && other.end > start;
    }
1357859
public int compare(final Version other) throws IncomparableException{
		// Cannot compare branch versions and others 
		if(!isBranch().equals(other.isBranch())){
			throw new IncomparableException();
		}
		
		// Compare digits
		final int minDigitSize = getDigitsSize() < other.getDigitsSize()? getDigitsSize(): other.getDigitsSize();
		
		for(int i = 0; i < minDigitSize ; i++){
			if(!getDigit(i).equals(other.getDigit(i))){
				return getDigit(i).compareTo(other.getDigit(i));
			}
		}
		
		// If not the same number of digits and the first digits are equals, the longest is the newer
		if(!getDigitsSize().equals(other.getDigitsSize())){
			return getDigitsSize() > other.getDigitsSize()? 1: -1;
		}

        if(isBranch() && !getBranchId().equals(other.getBranchId())){
			return getBranchId().compareTo(other.getBranchId());
		}
		
		// if the digits are the same, a snapshot is newer than a release
		if(isSnapshot() && other.isRelease()){
			return 1;
		}
		
		if(isRelease() && other.isSnapshot()){
			return -1;
		}
		
		// if both versions are releases, compare the releaseID
		if(isRelease() && other.isRelease()){
			return getReleaseId().compareTo(other.getReleaseId());
		}
		
		return 0;
	}
385517
@Override
    public int compareTo(MapElementContainer other) {
        if (this.priority < other.priority) {
            return -1;
        }
        if (this.priority > other.priority) {
            return 1;
        }
        return 0;
    }
971022
@Override
    public int compareTo(Edge other) {
        int cmp = super.compareTo(other);
        if (cmp != 0) {
            return cmp;
        }
        return type - other.type;
    }
74062
public SmallSet<E> diff(SmallSet<E> other) {
        SmallSet<E> tmp = new SmallSet<E>(this.size() - other.size());
        Sort.diffSortedLists(this.list, other.list, tmp.list);
        return tmp;
    }
1311238
private int compareOrder( CacheEntry other ) {

        if ( order > other.order ) {  //this order is lower so it has higher priority
            return 1;
        } else if ( order < other.order ) {//this order is higher so it has lower priority
            return -1;
        } else if ( order == other.order ) {//equal priority
            return 0;
        }
        die();
        return 0;
    }
311599
@Override
    public int compareTo(final AbstractAttr<T> otherObj) {
        if (otherObj == null) {
            return 1;
        } else {
            return value.compareTo(otherObj.value);
        }
    }
239080
@Override
    public int compareTo(final Path other) {
        if (other == null) {
            throw new IllegalArgumentException("other path must be specified");
        }
        // Just defer to alpha ordering since we're absolute
        return this.toString().compareTo(other.toString());
    }
462529
public void tally(RunnerStatistics other) {
        rightCount += other.rightCount();
        wrongCount += other.wrongCount();
        skippedCount += other.skippedCount();
        totalCount += other.totalCount();
    }
173879
@NonNull
  public CacheStats plus(@NonNull CacheStats other) {
    return new CacheStats(
        hitCount + other.hitCount,
        missCount + other.missCount,
        loadSuccessCount + other.loadSuccessCount,
        loadFailureCount + other.loadFailureCount,
        totalLoadTime + other.totalLoadTime,
        evictionCount + other.evictionCount,
        evictionWeight + other.evictionWeight);
  }
1104107
@Override
    public int compareTo(final FieldInfo other) {
        final int diff = declaringClassName.compareTo(other.declaringClassName);
        if (diff != 0) {
            return diff;
        }
        return name.compareTo(other.name);
    }
1011798
@Override
  public int compareTo(RuleMatch other) {
    Objects.requireNonNull(other);
    return Integer.compare(getFromPos(), other.getFromPos());
  }