*
 * Manages connection state, credit flow control, and provides
 * abstract methods for RDMA operations that must be implemented
 * by specific provider implementations.
 */
public abstract class RdmaConnection implements AutoCloseable {

    /**
     * RDMA connection state enumeration
     */
    public enum RdmaConnectionState {
        /** Connection is not established */
        DISCONNECTED,

 *
 * This abstract class provides common functionality for iterating
 * over directory entries in SMB file shares.
 *
 * @author mbechler
 */
public abstract class DirFileEntryEnumIteratorBase implements CloseableIterator<FileEntry> {

    private static final Logger log = LoggerFactory.getLogger(DirFileEntryEnumIteratorBase.class);

    private final SmbTreeHandleImpl treeHandle;

        // Configure with shorter intervals for testing
        resourceManager.configure(1000, 100, true, true);
    }

    /**
     * Test resource for tracking
     */
    static class TestResource implements AutoCloseable {
        private final AtomicBoolean closed = new AtomicBoolean(false);
        private final String name;

        TestResource(String name) {
            this.name = name;
        }

        when(parentLocator.isWorkgroup()).thenReturn(true);
    }

    /** Simple implementation of FileEntry for controlled inputs in tests. */
    private static final class StubFileEntry implements FileEntry {
        private final String name;
        private final int type;

        StubFileEntry(String name, int type) {
            this.name = name;
            this.type = type;
        }

 *
 * @deprecated since 4.0.0, use {@link org.apache.maven.api.services.SettingsBuilder} instead
 */
@Named
@Singleton
@Deprecated(since = "4.0.0")
public class DefaultSettingsBuilder implements SettingsBuilder {

    private SettingsReader settingsReader;

    private SettingsWriter settingsWriter;

    private SettingsValidator settingsValidator;

  "nullness", // too much trouble for the payoff
})
@GwtCompatible
@NullUnmarked // TODO(cpovirk): Annotate for nullness.
final class LocalCache<K, V> extends AbstractMap<K, V> implements ConcurrentMap<K, V> {

  /*
   * The basic strategy is to subdivide the table among Segments, each of which itself is a
   * concurrently readable hash table. The map supports non-blocking reads and concurrent writes

   * listeners will not be invoked.
   */
  private static final class ListenableFutureAdapter<V extends @Nullable Object>
      extends ForwardingFuture<V> implements ListenableFuture<V> {

    private static final ThreadFactory threadFactory =
        new ThreadFactoryBuilder()
            .setDaemon(true)
            .setNameFormat("ListenableFutureAdapter-thread-%d")

 *
 * @author Kurt Alfred Kluever
 * @author Jean-Philippe Aumasson
 * @author Daniel J. Bernstein
 */
@Immutable
final class SipHashFunction extends AbstractHashFunction implements Serializable {
  static final HashFunction SIP_HASH_24 =
      new SipHashFunction(2, 4, 0x0706050403020100L, 0x0f0e0d0c0b0a0908L);

  // The number of compression rounds.
  private final int c;

import java.util.Set;
import java.util.function.Function;

import org.codelibs.fess.crawler.exception.CrawlerSystemException;

/**
 * This class represents the result data of a crawl.
 */
public class ResultData implements Serializable {
    private static final long serialVersionUID = 1L;

    /** The name of the transformer. */
    protected String transformerName;

    /** The data of the result. */
    protected byte[] data;

 */
package org.codelibs.fess.app.pager;

import java.io.Serializable;
import java.util.List;

import org.codelibs.fess.util.ComponentUtil;

/**
 * Pager for Kuromoji.
 */
public class KuromojiPager implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * Default constructor.
     */
    public KuromojiPager() {
        // no-op
    }