//                                                                         ===========
    @Override
    public boolean hasPrimaryKey() {
        return false;
    }

    @Override
    public boolean hasCompoundPrimaryKey() {
        return false;
    }

    @Override
    protected UniqueInfo cpui() {
        return null;
    }

   */
  @CheckForNull @LazyInit private List<@Nullable Present<V>> values;

  CollectionFuture(
      ImmutableCollection<? extends ListenableFuture<? extends V>> futures,
      boolean allMustSucceed) {
    super(futures, allMustSucceed, true);

    List<@Nullable Present<V>> values =
        futures.isEmpty()
            ? Collections.<@Nullable Present<V>>emptyList()

    private static final String ALL_BOTS = "*";

    protected final Map<Pattern, Directive> directiveMap = new LinkedHashMap<>();

    private final List<String> sitemapList = new ArrayList<>();

    public boolean allows(final String path, final String userAgent) {
        final Directive directive = getMatchedDirective(userAgent);
        if (directive == null) {
            return true;
        }

     * @return a <code>Settings</code> object from the user settings file.
     * @throws IOException if any
     * @throws XmlPullParserException if any
     */
    Settings buildSettings(boolean useCachedSettings) throws IOException, XmlPullParserException;

    /**
     * @param userSettingsFile a given user settings file
     * @return a <code>Settings</code> object from the user settings file.

        while (tg.getParent() == null) {
            tg = tg.getParent();
        }

        ThreadGroup[] tgList = new ThreadGroup[tg.activeGroupCount()];
        tg.enumerate(tgList);

        boolean seen = false;

        for (ThreadGroup aTgList : tgList) {
            if (!aTgList.getName().equals(DefaultArtifactResolver.DaemonThreadCreator.THREADGROUP_NAME)) {
                continue;
            }

        this.bufferSize = bufferSize;
        this.outputCallback = outputCallback;

        br = new BufferedReader(new InputStreamReader(is, charset));
    }

    @Override
    public void run() {
        boolean running = true;
        while (running) {
            try {
                final String line = br.readLine();
                if (line == null) {
                    running = false;
                } else {

  }

  @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()) {