}

  @CanIgnoreReturnValue
  @Override
  public boolean remove(@CheckForNull Object key, @CheckForNull Object value) {
    return delegate().remove(key, value);
  }

  @CanIgnoreReturnValue
  @Override
  @CheckForNull
  public V replace(K key, V value) {
    return delegate().replace(key, value);
  }

  @CanIgnoreReturnValue
  @Override
  public boolean replace(K key, V oldValue, V newValue) {

  @CheckForNull
  N removeInEdge(E edge, boolean isSelfLoop);

  /** Remove {@code edge} from the set of outgoing edges. Returns the former successor node. */
  @CanIgnoreReturnValue
  N removeOutEdge(E edge);

  /**
   * Add {@code edge} to the set of incoming edges. Implicitly adds {@code node} as a predecessor.
   */
  void addInEdge(E edge, N node, boolean isSelfLoop);

                    methodDetailRenderer.renderTo(methodDoc, detailsSection);
                }
            }
        }
    }

    private boolean hasMethods(ClassDoc classDoc) {
        boolean hasMethods = false;
        if (!classDoc.getClassMethods().isEmpty()) {
            hasMethods = true;
        }
        for (ClassExtensionDoc extensionDoc : classDoc.getClassExtensions()) {

                    propertiesDetailRenderer.renderTo(propertyDoc, detailsSection);
                }
            }
        }
    }

    private boolean hasProperties(ClassDoc classDoc) {
        boolean hasProperties = false;
        if (!classDoc.getClassProperties().isEmpty()) {
            hasProperties = true;
        }
        for (ClassExtensionDoc extensionDoc : classDoc.getClassExtensions()) {

   *     null elements
   * @throws IllegalArgumentException if {@link Integer#MAX_VALUE} occurrences of {@code element}
   *     are already contained in this multiset
   */
  @CanIgnoreReturnValue
  @Override
  boolean add(@ParametricNullness E element);

  /**
   * Removes a number of occurrences of the specified element from this multiset. If the multiset

   * constructed.
   */
  @Override
  public boolean contains(@CheckForNull Object rowKey, @CheckForNull Object columnKey) {
    return containsRow(rowKey) && containsColumn(columnKey);
  }

  /**
   * Returns {@code true} if the provided column key is among the column keys provided when the
   * table was constructed.
   */
  @Override
  public boolean containsColumn(@CheckForNull Object columnKey) {

        }
    }

    @Override
    public void destroy() {
        destoryTimer.cancel();
        destoryTimer = null;
    }

    @Override
    public boolean generate(final String thumbnailId, final File outputFile) {
        if (logger.isDebugEnabled()) {
            logger.debug("Generate Thumbnail: {}", thumbnailId);
        }

        if (outputFile.exists()) {

     *
     * @see jcifs.smb.Kerb5Authenticator#isAnonymous()
     */
    @Override
    public boolean isAnonymous () {
        return false;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.smb.NtlmPasswordAuthenticator#isGuest()
     */
    @Override
    public boolean isGuest () {
        return false;
    }


    @Override

  public final void clear() {
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean isEmpty() {
    return size() == 0;
  }

  @Override
  public boolean containsKey(@CheckForNull Object key) {
    return get(key) != null;
  }

  @Override
  public boolean containsValue(@CheckForNull Object value) {
    return values().contains(value);
  }

 * <p>Here's an example that uses a user-defined finalization predicate:
 *
 * <pre>{@code
 * final WeakHashMap<Object, Object> map = new WeakHashMap<>();
 * map.put(new Object(), Boolean.TRUE);
 * GcFinalization.awaitDone(new FinalizationPredicate() {
 *   public boolean isDone() {
 *     return map.isEmpty();
 *   }
 * });
 * }</pre>
 *
 * <p>Even if your non-test code does not use finalization, you can use this class to test for