* all throwables.
   *
   * @return true if the caller should continue to wait for more references to be added to the
   *     queue, false if the associated FinalizableReferenceQueue is no longer referenced.
   */
  private boolean cleanUp(Reference<?> firstReference) {
    Method finalizeReferentMethod = getFinalizeReferentMethod();
    if (finalizeReferentMethod == null) {
      return false;
    }

      lastTimeoutInMillis = unit.toMillis(timeout);
      return inline.submit(Iterables.get(tasks, 0)).get(timeout, unit);
    }

    @Override
    public boolean isShutdown() {
      lastMethodCalled = "isShutdown";
      return false;
    }

    @Override
    public boolean isTerminated() {
      lastMethodCalled = "isTerminated";
      return false;
    }

    @Override

        return new Callable<File>() {
            @Override
            public File call() {
                return buildDistTask.get().getOutputs().getFiles().getSingleFile();
            }

            @Override
            public String toString() {
                return call().getAbsolutePath();
            }
        };
    }

    @Override
    public boolean hasNext() {
      return !nextElements.isEmpty();
    }

    @Override
    public boolean hasPrevious() {
      return !previousElements.isEmpty();
    }

    @Override
    public E next() {
      return transferElement(nextElements, previousElements);
    }

    @Override
    public int nextIndex() {
      return previousElements.size();
    }

    @Override

    return new String[length];
  }

  @Override
  public final String[] createValueArray(int length) {
    return new String[length];
  }

  /** Returns the original element list, unchanged. */
  @Override
  public Iterable<Entry<String, String>> order(List<Entry<String, String>> insertionOrder) {
    return insertionOrder;
  }

  }

  @Override
  public ElementOrder<N> incidentEdgeOrder() {
    return incidentEdgeOrder;
  }

  @Override
  @CanIgnoreReturnValue
  public boolean addNode(N node) {
    checkNotNull(node, "node");

    if (containsNode(node)) {
      return false;
    }

    addNodeInternal(node);
    return true;
  }

  /**

            return evaluate(expression, null);
        }

        @Override
        public File alignToBaseDirectory(File file) {
            if (translator != null) {
                return translator.translatePath(file);
            }
            return file;
        }
    }

    static class XmlConverter extends AbstractConfigurationConverter {
        @Override

        this.projects = projects;
    }

    public Map<MavenProject, List<MavenProject>> getAllProjects() {
        return projects;
    }

    public Map<String, String> aliases() {
        return aliases;
    }

    public Stream<MavenProject> projects() {
        return plan.keySet().stream();
    }

    public void addProject(MavenProject project, Map<String, BuildStep> steps) {

         * @return this builder for method chaining
         */
        public SearchConditionBuilder offset(final int offset) {
            this.offset = offset;
            return this;
        }

        /**
         * Sets the maximum number of results to return.
         *
         * @param size the maximum number of results
         * @return this builder for method chaining
         */

    return (Set<V>) super.replaceValues(key, values);
  }

  @Override
  public Set<Entry<K, V>> entries() {
    return (Set<Entry<K, V>>) super.entries();
  }

  @Override
  Set<Entry<K, V>> createEntries() {
    return new EntrySet();
  }

  private final class EntrySet extends Entries implements Set<Entry<K, V>> {
    @Override
    public int hashCode() {
      return Sets.hashCodeImpl(this);