*/
    public CrawlJob namespace(final String namespace) {
        this.namespace = namespace;
        return this;
    }

    /**
     * Sets the document expiration period in days.
     * Controls how long crawled documents remain in the search index.
     *
     * @param documentExpires the expiration period: -2 (system default), -1 (never expire),
     *                       0 or positive (expire after specified days)

	m, ok := b.tryGrowByReslice(len(s))
	if !ok {
		m = b.grow(len(s))
	}
	return copy(b.buf[m:], s), nil
}

// MinRead is the minimum slice size passed to a [Buffer.Read] call by
// [Buffer.ReadFrom]. As long as the [Buffer] has at least MinRead bytes beyond
// what is required to hold the contents of r, [Buffer.ReadFrom] will not grow the
// underlying buffer.
const MinRead = 512

      Comparator<? super K> comparator,
      boolean sameComparator,
      Iterable<? extends Entry<? extends K, ? extends V>> entries) {
    // "adding" type params to an array of a raw type should be safe as
    // long as no one can ever cast that same array instance back to a
    // raw type.
    @SuppressWarnings("unchecked")
    Entry<K, V>[] entryArray = (Entry[]) Iterables.toArray(entries, EMPTY_ENTRY_ARRAY);

        if (ComponentUtil.getFessConfig().isIncrementalCrawling()) {

            final SystemHelper systemHelper = ComponentUtil.getSystemHelper();
            final long startTime = systemHelper.getCurrentTimeAsLong();

            final FessConfig fessConfig = ComponentUtil.getFessConfig();
            final CrawlingConfigHelper crawlingConfigHelper = ComponentUtil.getCrawlingConfigHelper();

            .add("field33", new byte[0])
            .add("field34", new char[0])
            .add("field35", new short[0])
            .add("field36", new int[0])
            .add("field37", new long[0])
            .add("field38", new float[0])
            .add("field39", new double[0])
            .add("field40", new Object[0])
            .toString();

    @Tested public String publicField;
    @Tested private static Iterable<String> staticField;
    @Tested private final Object finalField;
    private volatile char volatileField;
    private transient long transientField;

    @Keep
    @Tested
    public A(Object finalField) {
      this.finalField = finalField;
    }

    @Tested
    abstract void abstractMethod();

    @Keep
    @Tested

     *
     * @since 22.0 (but only since 33.4.0 in the Android flavor)
     */
    @CanIgnoreReturnValue
    public Builder addAll(IntStream stream) {
      Spliterator.OfInt spliterator = stream.spliterator();
      long size = spliterator.getExactSizeIfKnown();
      if (size > 0) { // known *and* nonempty
        ensureRoomFor(Ints.saturatedCast(size));
      }
      spliterator.forEachRemaining((IntConsumer) this::add);

		case <-ctx.Done():
			r.err = ctx.Err()
			return ctx.Err()
		case dst <- meta:
		}
	}
}

// readFn will return all remaining objects
// and provide a callback for each entry read in order
// as long as true is returned on the callback.
func (r *metacacheReader) readFn(fn func(entry metaCacheEntry) bool) error {
	r.checkInit()
	if r.err != nil {
		return r.err
	}
	if r.current.name != "" {
		fn(r.current)

     * @return HTML response for the synonym item details
     */
    @Execute
    @Secured({ ROLE, ROLE + VIEW })
    public HtmlResponse details(final String dictId, final int crudMode, final long id) {
        verifyCrudMode(crudMode, CrudMode.DETAILS, dictId);
        saveToken();
        return asDetailsHtml().useForm(EditForm.class, op -> {
            op.setup(form -> {

        }
    }

    /**
     * Test AccessResultData implementation
     */
    public static class TestAccessResultData<T> implements AccessResultData<T>, Serializable {
        private static final long serialVersionUID = 1L;
        private T id;
        private byte[] data;
        private String encoding;
        private String transformerName;
        private String url;