formatter.append(" (");
                if (!registration.from.isEmpty()) {
                    formatter.append("from ");
                    formatter.appendValue(registration.from);
                }
                if (!registration.to.isEmpty()) {
                    if (!registration.from.isEmpty()) {

 * governing permissions and limitations under the License.
 */
package org.codelibs.core.beans.converter;

import static org.codelibs.core.lang.StringUtil.isEmpty;
import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotEmpty;
import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotNull;

import java.util.Date;

import org.codelibs.core.beans.Converter;

            .sorted()
            .collect(Collectors.toList());

        if (!compatibleAttrs.isEmpty()) {
            formatter.append(" declares ").append(style(StyledTextOutput.Style.SuccessHeader, describer.describeAttributeSet(compatibleAttrs)));
        }
        formatter.startChildren();
        if (!incompatibleAttrs.isEmpty()) {

        return () -> {
            TreeFormatter builder = new TreeFormatter();
            if (unmatchedVersions.isEmpty() && rejectedVersions.isEmpty()) {
                builder.node(String.format("Could not find any matches for %s as no versions of %s:%s are available.", selector, selector.getGroup(), selector.getModule()));
            } else {

    private final List<FileSystemLocationSnapshot> addedSnapshots = new ArrayList<>();

    public void publishSnapshotDiff(SnapshotHierarchy.SnapshotDiffListener snapshotDiffListener) {
        if (!removedSnapshots.isEmpty() || !addedSnapshots.isEmpty()) {
            snapshotDiffListener.changed(removedSnapshots, addedSnapshots);
        }
    }

    @Override
    public void nodeRemoved(FileSystemNode node) {
        node.rootSnapshots()

        CompileTransaction transaction = recompilationSpecProvider.initCompilationSpecAndTransaction(spec, recompilationSpec);
        return transaction.execute(workResult -> {
            if (Iterables.isEmpty(spec.getSourceFiles()) && spec.getClassesToProcess().isEmpty()) {
                LOG.info("None of the classes needs to be compiled! Analysis took {}. ", clock.getElapsed());

        @Override
        protected File computeNext() {
            advanceIfNecessary();
            if (stack.isEmpty()) {
                return endOfData();
            }
            return stack.getLast().next();
        }

        private void advanceIfNecessary() {
            while (!stack.isEmpty() && !hasNextWithCorrectDepth()) {
                if (stack.getLast().hasNext()) {

    public void complete(String header, Set<String> silencedVariants) {
        variantToWarnings.keySet().removeAll(silencedVariants);
        variantToWarnings.values().removeIf(VariantWarningCollector::isEmpty);
        if (!variantToWarnings.isEmpty()) {
            TreeFormatter treeFormatter = new TreeFormatter();
            treeFormatter.node(header + " warnings (silence with '" + disableMethod + "(variant)')");

    }

    public Conflict popConflict() {
        assert !conflicts.isEmpty();
        Conflict conflict = conflicts.pop();
        for (K participant : conflict.participants) {
            conflictsByParticipant.remove(participant);
        }
        return conflict;
    }

    public boolean isEmpty() {
        return conflicts.isEmpty();
    }

    boolean hasMatchingConflict(Predicate<T> predicate) {

    @Nonnull
    default Optional<Version> getLowerVersion() {
        return getVersions().isEmpty()
                ? Optional.empty()
                : Optional.of(getVersions().get(0));
    }

    @Nonnull
    default Optional<Version> getHigherVersion() {
        return getVersions().isEmpty()
                ? Optional.empty()
                : Optional.of(getVersions().get(getVersions().size() - 1));
    }