Examples with CompositeCron com.cronutils.model.CompositeCron used on opensource projects

Example 1 with CompositeCron

use of com.cronutils.model.CompositeCron in project cron-utils by jmrozanec.

the class CronParser method parse.

/**
 * Parse string with cron expression.
 *
 * @param expression - cron expression, never null
 * @return Cron instance, corresponding to cron expression received
 * @throws java.lang.IllegalArgumentException if expression does not match cron definition
 */
public Cron parse(final String expression) {
    Preconditions.checkNotNull(expression, "Expression must not be null");
    final String replaced = expression.replaceAll("\\s+", " ").trim();
    if (StringUtils.isEmpty(replaced)) {
        throw new IllegalArgumentException("Empty expression!");
    }
    if (expression.contains("||")) {
        List<Cron> crons = Arrays.stream(expression.split("\\|\\|")).map(this::parse).collect(Collectors.toList());
        return new CompositeCron(crons);
    }
    if (expression.contains("|")) {
        List<String> crons = new ArrayList<>();
        int cronscount = Arrays.stream(expression.split("\\s+")).mapToInt(s -> s.split("\\|").length).max().orElse(0);
        for (int j = 0; j < cronscount; j++) {
            StringBuilder builder = new StringBuilder();
            for (String s : expression.split("\\s+")) {
                if (s.contains("|")) {
                    builder.append(String.format("%s ", s.split("\\|")[j]));
                } else {
                    builder.append(String.format("%s ", s));
                }
            }
            crons.add(builder.toString().trim());
        }
        return new CompositeCron(crons.stream().map(this::parse).collect(Collectors.toList()));
    } else {
        final String[] expressionParts = replaced.toUpperCase().split(" ");
        final int expressionLength = expressionParts.length;
        String fieldWithTrailingCommas = Arrays.stream(expressionParts).filter(x -> x.endsWith(",")).findAny().orElse(null);
        if (fieldWithTrailingCommas != null) {
            throw new IllegalArgumentException(String.format("Invalid field value! Trailing commas not permitted! '%s'", fieldWithTrailingCommas));
        }
        final List<CronParserField> fields = expressions.get(expressionLength);
        if (fields == null) {
            throw new IllegalArgumentException(String.format("Cron expression contains %s parts but we expect one of %s", expressionLength, expressions.keySet()));
        }
        try {
            final int size = expressionParts.length;
            final List<CronField> results = new ArrayList<>(size + 1);
            for (int j = 0; j < size; j++) {
                results.add(fields.get(j).parse(expressionParts[j]));
            }
            return new SingleCron(cronDefinition, results).validate();
        } catch (final IllegalArgumentException e) {
            throw new IllegalArgumentException(String.format("Failed to parse cron expression. %s", e.getMessage()), e);
        }
    }
}

Example 2 with CompositeCron

use of com.cronutils.model.CompositeCron in project cron-utils by jmrozanec.

the class ExecutionTime method forCron.

/**
 * Creates execution time for given Cron.
 *
 * @param cron - Cron instance
 * @return ExecutionTime instance
 */
public static ExecutionTime forCron(final Cron cron) {
    if (cron instanceof SingleCron) {
        final Map<CronFieldName, CronField> fields = cron.retrieveFieldsAsMap();
        final ExecutionTimeBuilder executionTimeBuilder = new ExecutionTimeBuilder(cron);
        for (final CronFieldName name : CronFieldName.values()) {
            if (fields.get(name) != null) {
                switch(name) {
                    case SECOND:
                        executionTimeBuilder.forSecondsMatching(fields.get(name));
                        break;
                    case MINUTE:
                        executionTimeBuilder.forMinutesMatching(fields.get(name));
                        break;
                    case HOUR:
                        executionTimeBuilder.forHoursMatching(fields.get(name));
                        break;
                    case DAY_OF_WEEK:
                        executionTimeBuilder.forDaysOfWeekMatching(fields.get(name));
                        break;
                    case DAY_OF_MONTH:
                        executionTimeBuilder.forDaysOfMonthMatching(fields.get(name));
                        break;
                    case MONTH:
                        executionTimeBuilder.forMonthsMatching(fields.get(name));
                        break;
                    case YEAR:
                        executionTimeBuilder.forYearsMatching(fields.get(name));
                        break;
                    case DAY_OF_YEAR:
                        executionTimeBuilder.forDaysOfYearMatching(fields.get(name));
                        break;
                    default:
                        break;
                }
            }
        }
        return executionTimeBuilder.build();
    } else {
        return new CompositeExecutionTime(((CompositeCron) cron).getCrons().parallelStream().map(ExecutionTime::forCron).collect(Collectors.toList()));
    }
}