dummy ^= JOINER_ON_STRING.join(components).length();
    }
    return dummy;
  }

  /** {@link Joiner} with a character delimiter. */
  @Benchmark
  int joinerWithCharacterDelimiter(int reps) {
    int dummy = 0;
    for (int i = 0; i < reps; i++) {
      dummy ^= JOINER_ON_CHARACTER.join(components).length();
    }
    return dummy;
  }

  /**

                "${user.home}/.m2/settings.xml", "user.home", MavenSettingsBuilder.ALT_USER_SETTINGS_XML_LOCATION);

        return buildSettings(userSettingsFile);
    }

    public Settings buildSettings(boolean useCachedSettings) throws IOException, XmlPullParserException {
        return buildSettings();
    }

    public Settings buildSettings(File userSettingsFile) throws IOException, XmlPullParserException {

	if ctx == nil {
		LogIf(context.Background(), "audit", fmt.Errorf("context is nil"))
		return nil
	}
	return context.WithValue(ctx, contextAuditKey, audit)
}

// GetAuditEntry returns Audit entry if set.
func GetAuditEntry(ctx context.Context) *audit.Entry {
	if ctx != nil {
		r, ok := ctx.Value(contextAuditKey).(*audit.Entry)
		if ok {
			return r
		}
		r = &audit.Entry{
			Version:      internalAudit.Version,

    if (object == this) {
      return true;
    }

    if (object instanceof InternetDomainName) {
      InternetDomainName that = (InternetDomainName) object;
      return this.name.equals(that.name);
    }

    return false;
  }

  @Override
  public int hashCode() {
    return name.hashCode();
  }

        labelTypePager.setPageNumberList(labelTypeList.pageRange(op -> {
            op.rangeSize(fessConfig.getPagingPageRangeSizeAsInteger());
        }).createPageNumberList());

        return labelTypeList;
    }

    public void delete(final LabelType labelType) {

        labelTypeBhv.delete(labelType, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });

    public Appendable append(CharSequence csq) {
      result.append(csq);
      return this;
    }

    @Override
    public Appendable append(char c) {
      result.append(c);
      return this;
    }

    @Override
    public Appendable append(CharSequence csq, int start, int end) {
      result.append(csq, start, end);
      return this;
    }

    @Override
    public void flush() {
      flushed = true;

        return retrieve(request.getArtifact(), request.getLocalRepository(), request.getRemoteRepositories());
    }

    public List<ArtifactVersion> retrieveAvailableVersions(MetadataResolutionRequest request)
            throws ArtifactMetadataRetrievalException {
        return retrieveAvailableVersions(

    return (T[]) Array.newInstance(type, length);
  }

  /**
   * Returns a new array of the given length with the same type as a reference array.
   *
   * @param reference any array of the desired type
   * @param length the length of the new array
   */
  public static <T extends @Nullable Object> T[] newArray(T[] reference, int length) {
    return Platform.newArray(reference, length);
  }

  public E ceiling(E e) {
    return Iterables.<@Nullable E>getFirst(tailSet(e, true), null);
  }

  /** @since 12.0 */
  @GwtIncompatible // NavigableSet
  @Override
  @CheckForNull
  public E higher(E e) {
    return Iterables.<@Nullable E>getFirst(tailSet(e, false), null);
  }

  @Override
  public E first() {
    return iterator().next();
  }

  @Override
  public E last() {

    return new SampleElements<>(
        mapEntry(keys.e0(), values.e0()),
        mapEntry(keys.e1(), values.e1()),
        mapEntry(keys.e2(), values.e2()),
        mapEntry(keys.e3(), values.e3()),
        mapEntry(keys.e4(), values.e4()));
  }

  public E e0() {
    return e0;
  }

  public E e1() {
    return e1;
  }

  public E e2() {
    return e2;