ScoreFunctionCall<ScoreFunctionCreator<ScheduledJobCQ>> functionsLambda,
            final ConditionOptionCall<FunctionScoreQueryBuilder> opLambda) {
        ScheduledJobCQ cq = new ScheduledJobCQ();
        queryLambda.callback(cq);
        final Collection<FilterFunctionBuilder> list = new ArrayList<>();
        if (functionsLambda != null) {

  }

  private static final class ComplementRanges<C extends Comparable>
      extends ImmutableList<Range<C>> {

    private final ImmutableList<Range<C>> ranges;

    // True if the "positive" range set is empty or bounded below.
    private final boolean positiveBoundedBelow;

    // True if the "positive" range set is empty or bounded above.
    private final boolean positiveBoundedAbove;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/** A regex pattern implementation which is backed by the {@link Pattern}. */
@GwtIncompatible
final class JdkPattern extends CommonPattern implements Serializable {
  private final Pattern pattern;

  JdkPattern(Pattern pattern) {
    this.pattern = Preconditions.checkNotNull(pattern);
  }

  @Override
  public CommonMatcher matcher(CharSequence t) {

     * @throws InterruptedRuntimeException
     *             if any thread has interrupted the current thread.
     */
    public static void sleep(final long millis) {
        if (millis < 1L) {
            return;
        }
        try {
            Thread.sleep(millis);
        } catch (final InterruptedException e) {
            throw new InterruptedRuntimeException(e);
        }
    }

    /**

                        .connection("${test}/somepath")
                        .build())
                .build());

        ModelInterpolator interpolator = createInterpolator();

        final SimpleProblemCollector collector = new SimpleProblemCollector();
        Model out = interpolator.interpolateModel(model, new File("."), createModelBuildingRequest(context), collector);

        assertProblemFree(collector);

     */
    public ContainerNotAvailableException(final String componentName, final Throwable cause) {
        super(componentName + " is not available.", cause);
        this.componentName = componentName;
    }

    /**
     * Constructor with cause only.
     * @param cause The cause of the exception.
     */
    public ContainerNotAvailableException(final Throwable cause) {
        super("Container is not available.");

     */
    public SMBProtocolDecodingException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**
     * Constructs a new SMBProtocolDecodingException with the specified detail message.
     *
     * @param message the detail message
     */
    public SMBProtocolDecodingException(final String message) {
        super(message);
    }

    /**

     * @param message the detail message
     */
    public PACDecodingException(final String message) {
        this(message, null);
    }

    /**
     * Constructs a new PAC decoding exception with the specified cause.
     * @param cause the cause of the exception
     */
    public PACDecodingException(final Throwable cause) {
        this(null, cause);
    }

    /**

     * @param cause The cause.
     */
    public SuggestSettingsException(final Throwable cause) {
        super(cause);
    }

    /**
     * Constructs a new SuggestSettingsException with the specified detail message and cause.
     * @param msg The detail message.
     * @param cause The cause.
     */
    public SuggestSettingsException(final String msg, final Throwable cause) {
        super(msg, cause);
    }

 * does the deletion after confirming with the user.
 */
public class PruneChangelogsTask extends DefaultTask {
    private static final Logger LOGGER = Logging.getLogger(PruneChangelogsTask.class);

    private FileCollection changelogs;
    private final GitWrapper gitWrapper;
    private final Path rootDir;

    private boolean dryRun;

    @Inject