if (this instanceof Trusted) {
      return state == State.FAILURE ? throwable : null;
    }
    return null;
  }

  final void maybePropagateCancellationTo(@Nullable Future<?> related) {
    if (related != null & isCancelled()) {
      related.cancel(wasInterrupted());
    }
  }

  @Override
  public String toString() {
    StringBuilder builder = new StringBuilder().append(super.toString()).append("[status=");

     */
    @Nonnull
    <T> Optional<T> lookupOptional(Class<T> type, String name);

    /**
     * Performs a collection lookup for given typed components.
     *
     * @param type The component type.
     * @return The list of components. The list may be empty if no components found.
     * @param <T> The component type.
     * @throws LookupException if there is some provisioning related issue.
     */

    }

    @Override
    protected String asEsIndex() {
        return "fess_config.related_content";
    }

    @Override
    public String asEsIndexType() {
        return "related_content";
    }

    @Override
    public String asEsSearchType() {
        return "related_content";
    }

    @Override
    public RelatedContentDbm asDBMeta() {

        return asEsIndexType();
    }

    @Override
    protected String asEsIndex() {
        return "fess_config.related_query";
    }

    @Override
    public String asEsIndexType() {
        return "related_query";
    }

    @Override
    public String asEsSearchType() {
        return "related_query";
    }

    @Override
    public RelatedQueryDbm asDBMeta() {
        return RelatedQueryDbm.getInstance();

 * graph. The following test cases are left for the subclasses to handle:
 *
 * <ul>
 *   <li>Test cases related to whether the graph is directed or undirected.
 *   <li>Test cases related to the specific implementation of the {@link Graph} interface.
 * </ul>
 *
 * TODO(user): Make this class generic (using <N, E>) for all node and edge types.
 * TODO(user): Differentiate between directed and undirected edge strings.
 */

    //                                                                          ==========
    protected final String _tableDbName = "related_content";
    protected final String _tableDispName = "related_content";
    protected final String _tablePropertyName = "RelatedContent";

    public String getTableDbName() {
        return _tableDbName;
    }

    @Override

    //                                                                          ==========
    protected final String _tableDbName = "related_query";
    protected final String _tableDispName = "related_query";
    protected final String _tablePropertyName = "RelatedQuery";

    public String getTableDbName() {
        return _tableDbName;
    }

    @Override

        checkVersionsOrder(b, d);
        checkVersionsOrder(a, d);
    }

    /**
     * Test all versions are equal when starting with many leading zeroes regardless of string length
     * (related to MNG-6572 optimization)
     */
    @Test
    void testVersionEqualWithLeadingZeroes() {
        // versions with string lengths from 1 to 19
        String[] arr = new String[] {

    private static final String INDEXING_HELPER = "indexingHelper";

    private static final String VIRTUAL_HOST_HELPER = "virtualHostHelper";

    private static final String RELATED_CONTENT_HELPER = "relatedContentHelper";

    private static final String RELATED_QUERY_HELPER = "relatedQueryHelper";

    private static final String CRAWLER_STATS_HELPER = "crawlerStatsHelper";

  }

  /**
   * Not really a signature -- just the parts that affect whether one method is a fauxveride of a
   * method from an ancestor class.
   *
   * <p>See JLS 8.4.2 for the definition of the related "override-equivalent."
   */
  private static final class MethodSignature implements Comparable<MethodSignature> {
    final String name;
    final List<Class<?>> parameterTypes;
    final TypeSignature typeSignature;