Returns whether, for all offsets present in both groups, this {@code OffsetGroup}'s
offset {@link Offset#followsOrEquals(Offset)} (Offset)} the other's.
967606
public boolean followsOrEqualsForAllOffsetTypesInBoth(final OffsetGroup other) {
    return charOffset().followsOrEquals(other.charOffset())
        && edtOffset().followsOrEquals(other.edtOffset())
        && (!byteOffset().isPresent() || !other.byteOffset().isPresent()
                || byteOffset().get().followsOrEquals(other.byteOffset().get()))
        && (!asrTime().isPresent() || !other.asrTime().isPresent()
                || asrTime().get().followsOrEquals(other.asrTime().get()));
  }
914152
public boolean intersectsWithOrTouches(Range other) {
        return contains(other.lower) || contains(other.upper - 1) || (other.upper > upper && other.lower < lower) ||
                other.lower == upper || other.upper == lower;
    }
1329579
@Override
	public boolean hasNext() {

		// trying to iterate over an empty structure...

		if ( group == null)
			return false;

		// if there is another group ...
		if ( current_atom_pos < group.size()-1 ) {
			return true ;
		} else {
			// search through the next groups if they contain an atom
			if (groupiter != null) {
				GroupIterator tmp = (GroupIterator) groupiter.clone() ;
				while (tmp.hasNext()) {
					Group tmpg = tmp.next() ;

					if ( tmpg.size() > 0 ) {
						return true ;
					}

				}
			} else {
				// just an iterator over one group ...
				return false ;
			}
		}
		return false ;
	}
85818
public boolean contains( Location other )
	{
		if( isSameStrand( other ))
		{
			return ( mStart <= other.mStart && mEnd >= other.mEnd );
		}
		else
		{
			throw new IllegalArgumentException( "Locations are on opposite strands." );
		}
	}
113552
@GwtIncompatible("incompatible method")
    private static boolean annotationArrayMemberEquals(final Annotation[] a1, final Annotation[] a2) {
        if (a1.length != a2.length) {
            return false;
        }
        for (int i = 0; i < a1.length; i++) {
            if (!equals(a1[i], a2[i])) {
                return false;
            }
        }
        return true;
    }
1002941
public boolean overlapsWith(IndexRange other) {
        checkArgNotNull(other, "other");
        return end > other.start && other.end > start;
    }
402222
public final boolean overlaps(HString other) {
      if (other == null) {
         return false;
      }
      return (document() != null && other.document() != null) &&
                (document() == other.document()) &&
                super.overlaps(other);
   }
962621
public List<Permutation> transversal(final PermutationGroup subgroup) {
        final long m = this.order() / subgroup.order();
        final List<Permutation> results = new ArrayList<Permutation>();
        Backtracker transversalBacktracker = new Backtracker() {

            private boolean finished = false;

            @Override
            public void applyTo(Permutation p) {
                for (Permutation f : results) {
                    Permutation h = f.invert().multiply(p);
                    if (subgroup.test(h) == size) {
                        return;
                    }
                }
                results.add(p);
                if (results.size() >= m) {
                    this.finished = true;
                }
            }

            @Override
            public boolean isFinished() {
                return finished;
            }

        };
        this.apply(transversalBacktracker);
        return results;
    }
507087
public GroupOptions setOffset(@Nullable Integer offset) {

		this.offset = offset == null ? null : Math.max(0, offset);
		return this;
	}
19376
public static boolean hasOverlappingOffsets(TermOccurrence theOcc, Collection<TermOccurrence> theOccCollection) {
		for(TermOccurrence o:theOccCollection)
			if(areOffsetsOverlapping(theOcc, o))
				return true;
		return false;
	}
522560
public static <K> Matcher<Multimap<K, ?>> hasSameKeySet(final Set<K> comparison) {
        return IsMultimapWithKeySet.hasSameKeySet(comparison);
    }
810886
public static boolean getBoolean(MemorySegment[] segments, int offset) {
		if (inFirstSegment(segments, offset, 1)) {
			return segments[0].getBoolean(offset);
		} else {
			return getBooleanMultiSegments(segments, offset);
		}
	}
982907
private static final boolean longMultisetsEqual(long[] firstDeps, long[] secondDeps) {
    if (firstDeps.length != secondDeps.length) {
      return false;
    }
    Arrays.sort(firstDeps);
    Arrays.sort(secondDeps);

    for (int i = 0; i < firstDeps.length; i++) {
      if (firstDeps[i] != secondDeps[i]) {
        return false;
      }
    }
    return true;
  }
268956
public static boolean bufEquals(byte onearray[], byte twoarray[]) {
        if (onearray == twoarray)
            return true;
        boolean ret = (onearray.length == twoarray.length);
        if (!ret) {
            return ret;
        }
        for (int idx = 0; idx < onearray.length; idx++) {
            if (onearray[idx] != twoarray[idx]) {
                return false;
            }
        }
        return true;
    }
1099777
private static boolean multiPointExactlyEqualsMultiPoint_(
			MultiPoint multipoint_a, MultiPoint multipoint_b, double tolerance,
			ProgressTracker progress_tracker) {
		if (multipoint_a.getPointCount() != multipoint_b.getPointCount())
			return false;

		Point2D ptA = new Point2D(), ptB = new Point2D();
		boolean bAllPointsEqual = true;
		double tolerance_sq = tolerance * tolerance;

		for (int i = 0; i < multipoint_a.getPointCount(); i++) {
			multipoint_a.getXY(i, ptA);
			multipoint_b.getXY(i, ptB);

			if (Point2D.sqrDistance(ptA, ptB) > tolerance_sq) {
				bAllPointsEqual = false;
				break;
			}
		}

		if (!bAllPointsEqual)
			return false;

		return true;
	}
865998
public boolean hasGroup(String groupName) {
        boolean result = false;
        for (Group item : getGroupsList()) {
            if (item.getName().equals(groupName)) {
                result = true;
            }
        }
        return result;
    }
701241
public boolean contains(final OffsetType x) {
    return x.asInt() >= startInclusive().asInt() && x.asInt() <= endInclusive().asInt();
  }