/** Updates this hasher with the given byte. */
  protected abstract void update(byte b);

  /** Updates this hasher with the given bytes. */
  protected void update(byte[] b) {
    update(b, 0, b.length);
  }

  /** Updates this hasher with {@code len} bytes starting at {@code off} in the given buffer. */
  protected void update(byte[] b, int off, int len) {
    for (int i = off; i < off + len; i++) {

 *
 * <pre>{@code
 * new TypeVisitor() {
 *   protected void visitParameterizedType(ParameterizedType t) {
 *     visit(t.getOwnerType());
 *     visit(t.getActualTypeArguments());
 *   }
 *   protected void visitGenericArrayType(GenericArrayType t) {
 *     visit(t.getGenericComponentType());
 *   }
 *   protected void visitTypeVariable(TypeVariable<?> t) {

@GwtIncompatible
@ElementTypesAreNonnullByDefault
public abstract class ForwardingCache<K, V> extends ForwardingObject implements Cache<K, V> {

  /** Constructor for use by subclasses. */
  protected ForwardingCache() {}

  @Override
  protected abstract Cache<K, V> delegate();

  /** @since 11.0 */
  @Override
  @CheckForNull
  public V getIfPresent(Object key) {
    return delegate().getIfPresent(key);
  }

   */
  @CheckForNull
  protected abstract char[] escape(char c);

  /**
   * Returns the escaped form of a given literal string, starting at the given index. This method is
   * called by the {@link #escape(String)} method when it discovers that escaping is required. It is
   * protected to allow subclasses to override the fastpath escaping function to inline their

    //
    @Resource
    protected RoleBhv roleBhv;

    @Resource
    protected RoleTypeBhv roleTypeBhv;

    @Resource
    protected LabelTypeBhv labelTypeBhv;

    @Resource
    protected WebConfigBhv webConfigBhv;

    @Resource
    protected FileConfigBhv fileConfigBhv;

    @Resource
    protected DataConfigBhv dataConfigBhv;

    @Resource

public class DefaultSearcher extends RankFusionSearcher {

    private static final Logger logger = LogManager.getLogger(DefaultSearcher.class);

    @Override
    protected SearchResult search(final String query, final SearchRequestParams params, final OptionalThing<FessUserBean> userBean) {
        final int pageSize = params.getPageSize();
        LaRequestUtil.getOptionalRequest().ifPresent(request -> {

 * @param <T5>
 *            5番目の値の型
 */
public class Tuple5<T1, T2, T3, T4, T5> {

    /** 1番目の値 */
    protected T1 value1;

    /** 2番目の値 */
    protected T2 value2;

    /** 3番目の値 */
    protected T3 value3;

    /** 4番目の値 */
    protected T4 value4;

    /** 5番目の値 */
    protected T5 value5;

    /**
     * 4つの値の組を作成して返します。
     *
     * @param <T1>
     *            1番目の値の型

 * @author Hayward Chan
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public class BiMapGenerators {
  public static class ImmutableBiMapGenerator extends TestStringBiMapGenerator {
    @Override
    protected BiMap<String, String> create(Entry<String, String>[] entries) {
      ImmutableBiMap.Builder<String, String> builder = ImmutableBiMap.builder();
      for (Entry<String, String> entry : entries) {
        checkNotNull(entry);

    table.put("a", 1, 'a');
    table.put("z", 1, 'a');
    return table;
  }

  @Override
  protected Map<String, Map<Integer, Character>> makePopulatedMap() {
    TreeBasedTable<String, Integer, Character> table = makeTable();
    populateTable(table);
    return table.rowMap().subMap("b", "x");
  }

  @Override
  protected Map<String, Map<Integer, Character>> makeEmptyMap() {
    return makeTable().rowMap().subMap("b", "x");
  }

    private final List<T> backingList;

    StandardImplForwardingList(List<T> backingList) {
      this.backingList = backingList;
    }

    @Override
    protected List<T> delegate() {
      return backingList;
    }

    @Override
    public boolean add(T element) {
      return standardAdd(element);
    }

    @Override