Returns whether this path starts with the same segments and
has the same {@link #isAbsolute()} value.

@param other the path, which might be a prefix of this path
@return whether the given path is a prefix of this path
352585
public boolean startsWith(Path other) {
		if (isAbsolute() != other.isAbsolute())
			return false;
		List<String> otherSegments = other.getSegments();
		List<String> thisSegments = getSegments();
		int otherSegmentSize = otherSegments.size();
		int thisSegmentSize = thisSegments.size();
		if (otherSegmentSize > thisSegmentSize) {
			return false;
		}
		for (int i = 0; i < otherSegmentSize; i++) {
			String otherSeg = otherSegments.get(i);
			String thisSeg = thisSegments.get(i);
			if (!otherSeg.equals(thisSeg))
				return false;
		}
		return true;
	}
1137718
public boolean isNewerThan(SetElement other) {
    if (other == null) {
      return true;
    }
    return this.timestamp.isNewerThan(other.timestamp);
  }
1090507
public boolean isAbsolute(LocPathIterator path)
  {
  	int analysis = path.getAnalysisBits();
    boolean isAbs = (WalkerFactory.isSet(analysis, WalkerFactory.BIT_ROOT) || 
           WalkerFactory.isSet(analysis, WalkerFactory.BIT_ANY_DESCENDANT_FROM_ROOT));
    if(isAbs)
    {
    	isAbs = m_absPathChecker.checkAbsolute(path);
    }
    return isAbs;
  }
1045811
public boolean isSamePath(DataDescriptor other) {
        if (other == null)
            return false;
        if (type == TYPE_INVALID || other.getType() == TYPE_INVALID)
            return false;
        if (type != other.getType())
            return false;
        if (dataPath == null || other.getPath() == null)
            return false;

        String[] otherPath = other.getPath();
        if (dataPath.length != otherPath.length)
            return false;
        for (int i = 0; i < dataPath.length; i++) {
            if (!dataPath[i].equals(otherPath[i]))
                return false;
        }
        return true;
    }
17399
public boolean nextPath() {
		// post-increment
		m_currentPathIndex = m_nextPathIndex;
		if (m_currentPathIndex >= m_parent.getPathCount())
			return false;

		m_currentSegmentIndex = -1;
		m_nextSegmentIndex = 0;
		m_segmentCount = _getSegmentCount(m_currentPathIndex);
		m_pathBegin = m_parent.getPathStart(m_currentPathIndex);
		m_nextPathIndex++;
		return true;
	}
755605
public boolean isBeforeRange(final Range<T> other) {
        if (other == null) {
            return false;
        }

        return other.lowerEndpoint.isClosed ? isBefore(other.lowerEndpoint.value) : this.upperEndpoint.compareTo(other.lowerEndpoint.value) <= 0;
    }
1305788
private static boolean startsWith(List<?> list, List<?> other) {
    return list.size() >= other.size() && list.subList(0, other.size()).equals(other);
  }
1184097
public boolean followsForAllOffsetTypesInBoth(final OffsetGroup other) {
    return charOffset().follows(other.charOffset())
        && edtOffset().follows(other.edtOffset())
        && (!byteOffset().isPresent() || !other.byteOffset().isPresent()
                || byteOffset().get().follows(other.byteOffset().get()))
        && (!asrTime().isPresent() || !other.asrTime().isPresent()
                || asrTime().get().follows(other.asrTime().get()));
  }
1338590
public boolean contains(Bbox other) {
		if (other.getX() < this.getX()) {
			return false;
		}
		if (other.getY() < this.getY()) {
			return false;
		}
		if (other.getEndPoint().getX() > this.getEndPoint().getX()) {
			return false;
		}
		if (other.getEndPoint().getY() > this.getEndPoint().getY()) {
			return false;
		}
		return true;
	}
478315
public static boolean hasRoot(String path, String root) {
        String p = cleanPath(path);
        String r = cleanPath(root);
        return p.equals(r)
               || r.equals(cleanPath(ROOT.getPath()))
               || p.startsWith(r + SEPARATOR);
    }
499900
public boolean isNullOnSomePath() {
        int baseKind = getBaseKind();
        if (NCP_EXTRA_BRANCH) {
            // Note: NCP_EXTRA_BRANCH is an experimental feature
            // to see how many false warnings we get when we allow
            // two branches between an explicit null and a
            // a dereference.
            return baseKind == NSP || baseKind == NCP2;
        } else {
            return baseKind == NSP;
        }
    }
807728
public boolean isAbsolute() {
		final int start = hasWindowsDrive(uri.getPath(), true) ? 3 : 0;
		return uri.getPath().startsWith(SEPARATOR, start);
	}
712820
public boolean hasSameData(ZFrame other)
    {
        if (other == null) {
            return false;
        }

        if (size() == other.size()) {
            return Arrays.equals(data, other.data);
        }
        return false;
    }
610610
public boolean startsWith(byte[] prefix) {
        if ((prefix.length == 0) || (prefix.length > size())) {
            // no match would be possible
            return false;
        }
        boolean match = true;
        int i = 0;
        int j = this.currentReadPosition;
        while (match && (i < prefix.length)) {
            if (this.buffer[j] != prefix[i]) {
                match = false;
            }
            i++;
            j = (j + 1) % this.buffer.length;
        }
        return match;
    }
178121
private static boolean hasEqualParts(final String input,
                                       final int beginTo,
                                       final int endFrom) {
    String begin = input.substring(0, beginTo);
    String end = input.substring(endFrom);
    return begin.equals(end);
  }
663043
private boolean startsWithCustomRoot(String path) {
		for (Enumeration<String> it = customRoots.elements(); it != null
				&& it.hasMoreElements();) {
			if (path.startsWith(it.nextElement())) {
				return true;
			}
		}
		return false;
	}
426239
public boolean intersects(Interval1D<V> other) {
    if (other.hi.compareTo(this.lo) < 0) {
      return false;
    }
    if (this.hi.compareTo(other.lo) < 0) {
      return false;
    }

    return true;
  }