@GuardedBy("lock")
  private final List<LogRecord> list = new ArrayList<>();

  /** Adds the most recently logged record to our list. */
  @Override
  public void publish(@Nullable LogRecord record) {
    synchronized (lock) {
      if (record != null) {
        list.add(record);
      }
    }
  }

  @Override
  public void flush() {}

  @Override
  public void close() {}

  /** Use {@link MoreExecutors#newSequentialExecutor} */
  SequentialExecutor(Executor executor) {
    this.executor = Preconditions.checkNotNull(executor);
  }

  /**
   * Adds a task to the queue and makes sure a worker thread is running.
   *
   * <p>If this method throws, e.g. a {@code RejectedExecutionException} from the delegate executor,

  abstract Network<Integer, String> createGraph();

  /**
   * A proxy method that adds the node {@code n} to the graph being tested. In case of Immutable
   * graph implementations, this method should replace {@link #network} with a new graph that
   * includes this node.
   */
  abstract void addNode(Integer n);

  /**
   * A proxy method that adds the edge {@code e} to the graph being tested. In case of Immutable

     */
    @CanIgnoreReturnValue
    @Override
    public Builder<K, V> put(K key, V value) {
      super.put(key, value);
      return this;
    }

    /**
     * Adds the given {@code entry} to the bimap. Duplicate keys or values are not allowed, and will
     * cause {@link #build} to fail.
     *
     * @since 19.0
     */
    @CanIgnoreReturnValue
    @Override

        User u = user;
        for (final AuthenticationChain chain : chains) {
            u = chain.load(u);
        }
        return u;
    }

    /**
     * Adds an authentication chain to the manager.
     * @param chain The authentication chain to add.
     */
    public void addChain(final AuthenticationChain chain) {
        chains = ArrayUtils.addAll(chains, chain);
    }

    /**

                    if (StringUtil.isNotEmpty(role)) {
                        roleSet.add(role);
                    }
                }
            }
        } else {
            final String[] roles = rolesStr.split(roleSeparator);
            for (final String role : roles) {
                if (StringUtil.isNotEmpty(role)) {
                    roleSet.add(role);
                }
            }
        }
    }

     */
    public Map<String, String> getQueryMap() {
        return queryMap;
    }

    /**
     * Adds a query to the query map with the specified display key.
     *
     * @param key the display key for the query
     * @param query the query string to add
     */
    public void addQuery(final String key, final String query) {
        queryMap.put(key, query);
    }

    /**

 * own subclass of {@link ListenableFuture}, complete with a method like {@link #from} to adapt an
 * existing {@code ListenableFuture}, implemented atop a {@link ForwardingListenableFuture} that
 * forwards to that future and adds the desired methods.
 */
@GwtCompatible
final class ForwardingFluentFuture<V extends @Nullable Object> extends FluentFuture<V> {
  private final ListenableFuture<V> delegate;

                }
            }
        }
        return BucketOrder.count(false);
    }

    /**
     * Adds a query facet to the existing query array.
     * If no queries exist, creates a new array with the provided query.
     *
     * @param s the query string to add as a facet
     */
    public void addQuery(final String s) {
        if (query == null) {
            query = new String[] { s };

        return map.containsKey(o);
    }

    /**
     * Adds the specified element to this set if it is not already present.
     *
     * @param o
     *            element to be added to this set.
     * @return true if the set did not already contain the specified
     *         element.
     */
    @Override
    public boolean add(final E o) {
        return map.put(o, PRESENT) == null;
    }