* lesser. For example, {@code [] < [1.0] < [1.0, 2.0] < [2.0]}.
   *
   * <p>The returned comparator is inconsistent with {@link Object#equals(Object)} (since arrays
   * support only identity equality), but it is consistent with {@link Arrays#equals(double[],
   * double[])}.
   *
   * @since 2.0
   */
  public static Comparator<double[]> lexicographicalComparator() {

        }
      };
    }

    @Override
    public int size() {
      if (upperBoundWindow.equals(Range.all())) {
        return rangesByLowerBound.size();
      }
      return Iterators.size(entryIterator());
    }

    @Override
    public boolean isEmpty() {
      return upperBoundWindow.equals(Range.all())
          ? rangesByLowerBound.isEmpty()
          : !entryIterator().hasNext();
    }
  }

 * high contention, expected throughput of this class is significantly higher, at the expense of
 * higher space consumption.
 *
 * <p>This class extends {@link Number}, but does not define methods such as {@code
 * equals}, {@code hashCode} and {@code compareTo} because instances are expected to be mutated, and
 * so are not useful as collection keys.
 *
 * <p>jsr166e note: This class is targeted to be placed in java.util.concurrent.atomic.

                String className = fqcn.substring(lastDot + 1);
                LOGGER.info("IGNORING package: " + packageName + ", class: " + className);
                if (packageName.equals(lastPackageName) == false) {
                    currentClasses = splitPackages.get(packageName);
                    lastPackageName = packageName;
                }

                if (currentClasses == null) {

        // Verify the stack trace contains this test method
        boolean foundTestMethod = false;
        for (StackTraceElement element : exception.getStackTrace()) {
            if (element.getMethodName().equals("test_stackTrace")) {
                foundTestMethod = true;
                break;
            }
        }
        assertTrue(foundTestMethod);
    }

    @Test

   * Returns an immutable map containing the same entries as {@code map}. If {@code map} somehow
   * contains entries with duplicate keys (for example, if it is a {@code SortedMap} whose
   * comparator is not <i>consistent with equals</i>), the results of this method are undefined.
   *
   * <p><b>Note:</b> Despite what the method name suggests, if {@code map} is an {@code
   * ImmutableClassToInstanceMap}, no copy will actually be performed.
   *

            return sb.toString();
        }

        @Override
        public boolean equals(final Object other) {
            if (other == null || !(other instanceof MyToken)) {
                return false;
            }
            final MyToken o = (MyToken) other;
            if (!word.equals(o.word)) {
                return false;
            }
            if (startOffset != o.startOffset) {

    public OptionalEntity<DictionaryFile<? extends DictionaryItem>> getDictionaryFile(final String id) {
        for (final DictionaryFile<? extends DictionaryItem> dictFile : getDictionaryFiles()) {
            if (dictFile.getId().equals(id)) {
                return OptionalEntity.of(dictFile);
            }
        }
        return OptionalEntity.empty();
    }

    /**

   * example, {@code [] < [1L] < [1L, 2L] < [2L]}.
   *
   * <p>The returned comparator is inconsistent with {@link Object#equals(Object)} (since arrays
   * support only identity equality), but it is consistent with {@link Arrays#equals(long[],
   * long[])}.
   *
   * @since 2.0
   */
  public static Comparator<long[]> lexicographicalComparator() {

        MetadataGraphVertex v = new MetadataGraphVertex(md);
        v.setCompareVersion(versionedVertices);
        v.setCompareScope(scopedVertices);

        for (MetadataGraphVertex gv : vertices) {
            if (gv.equals(v)) {
                return gv;
            }
        }

        return null;
    }
    // ------------------------------------------------------------------------