#520: Implement support for @reboot.

Author: jmrozanec

src/main/java/com/cronutils/builder/CronBuilder.java

@@ -14,6 +14,7 @@
 package com.cronutils.builder;
 
 import com.cronutils.model.Cron;
+import com.cronutils.model.RebootCron;
 import com.cronutils.model.SingleCron;
 import com.cronutils.model.definition.CronDefinition;
 import com.cronutils.model.field.CronField;
@@ -210,6 +211,10 @@ public static Cron hourly(final CronDefinition definition){
         return builder.instance();
     }
 
+    public static Cron reboot(final CronDefinition definition){
+        return new RebootCron(definition);
+    }
+
     @VisibleForTesting
     CronBuilder addField(final CronFieldName name, final FieldExpression expression) {
         checkState(definition != null, "CronBuilder not initialized.");

src/main/java/com/cronutils/model/RebootCron.java

@@ -0,0 +1,96 @@
+package com.cronutils.model;
+
+import com.cronutils.mapper.CronMapper;
+import com.cronutils.model.definition.CronConstraint;
+import com.cronutils.model.definition.CronDefinition;
+import com.cronutils.model.field.CronField;
+import com.cronutils.model.field.CronFieldName;
+import com.cronutils.model.field.expression.visitor.ValidationFieldExpressionVisitor;
+import com.cronutils.utils.Preconditions;
+
+import java.util.*;
+
+public class RebootCron implements Cron {
+    private static final long serialVersionUID = 7487370826825439099L;
+    private final CronDefinition cronDefinition;
+
+    /**
+     * Creates a Cron with the given cron definition and the given fields.
+     * @param cronDefinition the definition to use for this Cron
+     */
+    public RebootCron(final CronDefinition cronDefinition) {
+        this.cronDefinition = Preconditions.checkNotNull(cronDefinition, "CronDefinition must not be null");
+    }
+
+    /**
+     * Retrieve value for cron field.
+     *
+     * @param name - cron field name.
+     *             If null, a NullPointerException will be raised.
+     * @return CronField that corresponds to given CronFieldName
+     */
+    public CronField retrieve(final CronFieldName name) {
+        Preconditions.checkNotNull(name, "CronFieldName must not be null");
+        return null;
+    }
+
+    /**
+     * Retrieve all cron field values as map.
+     *
+     * @return unmodifiable Map with key CronFieldName and values CronField, never null
+     */
+    public Map<CronFieldName, CronField> retrieveFieldsAsMap() {
+        return Collections.unmodifiableMap(new HashMap<>());
+    }
+
+    public String asString() {
+        return "@reboot";
+    }
+
+    public CronDefinition getCronDefinition() {
+        return cronDefinition;
+    }
+
+    /**
+     * Validates this Cron instance by validating its cron expression.
+     *
+     * @return this Cron instance
+     * @throws IllegalArgumentException if the cron expression is invalid
+     */
+    public Cron validate() {
+        for (final Map.Entry<CronFieldName, CronField> field : retrieveFieldsAsMap().entrySet()) {
+            final CronFieldName fieldName = field.getKey();
+            field.getValue().getExpression().accept(
+                    new ValidationFieldExpressionVisitor(getCronDefinition().getFieldDefinition(fieldName).getConstraints())
+            );
+        }
+        for (final CronConstraint constraint : getCronDefinition().getCronConstraints()) {
+            if (!constraint.validate(this)) {
+                throw new IllegalArgumentException(String.format("Invalid cron expression: %s. %s", asString(), constraint.getDescription()));
+            }
+        }
+        return this;
+    }
+
+    /**
+     * Provides means to compare if two cron expressions are equivalent.
+     *
+     * @param cronMapper - maps 'cron' parameter to this instance definition;
+     * @param cron       - any cron instance, never null
+     * @return boolean - true if equivalent; false otherwise.
+     */
+    public boolean equivalent(final CronMapper cronMapper, final Cron cron) {
+        return asString().equals(cronMapper.map(cron).asString());
+    }
+
+    /**
+     * Provides means to compare if two cron expressions are equivalent.
+     * Assumes same cron definition.
+     *
+     * @param cron - any cron instance, never null
+     * @return boolean - true if equivalent; false otherwise.
+     */
+    public boolean equivalent(final Cron cron) {
+        return asString().equals(cron.asString());
+    }
+}

src/main/java/com/cronutils/model/SingleCron.java

@@ -17,7 +17,7 @@ public class SingleCron implements Cron {
     private String asString;
 
     /**
-     * Creates a Cron with the iven cron definition and the given fields.
+     * Creates a Cron with the given cron definition and the given fields.
      * @param cronDefinition the definition to use for this Cron
      * @param fields the fields that should be used
      */

src/main/java/com/cronutils/model/definition/CronDefinition.java

@@ -40,11 +40,13 @@ public class CronDefinition implements Serializable {
      *                         Throws an IllegalArgumentException if an empty list is received
      */
     public CronDefinition(final List<FieldDefinition> fieldDefinitions, final Set<CronConstraint> cronConstraints, Set<CronNicknames> cronNicknames, final boolean matchDayOfWeekAndDayOfMonth) {
-        Preconditions.checkNotNull(fieldDefinitions, "Field definitions must not be null");
-        Preconditions.checkNotNull(cronConstraints, "Cron validations must not be null");
         Preconditions.checkNotNull(cronNicknames, "Cron nicknames must not be null");
-        Preconditions.checkNotNullNorEmpty(fieldDefinitions, "Field definitions must not be empty");
-        Preconditions.checkArgument(!fieldDefinitions.get(0).isOptional(), "The first field must not be optional");
+        if(!cronNicknames.contains(CronNicknames.REBOOT)){
+            Preconditions.checkNotNull(fieldDefinitions, "Field definitions must not be null");
+            Preconditions.checkNotNull(cronConstraints, "Cron validations must not be null");
+            Preconditions.checkNotNullNorEmpty(fieldDefinitions, "Field definitions must not be empty");
+            Preconditions.checkArgument(!fieldDefinitions.get(0).isOptional(), "The first field must not be optional");
+        }
         this.fieldDefinitions = new EnumMap<>(CronFieldName.class);
         for (final FieldDefinition field : fieldDefinitions) {
             this.fieldDefinitions.put(field.getFieldName(), field);

src/main/java/com/cronutils/model/definition/CronDefinitionBuilder.java

@@ -194,6 +194,16 @@ public CronDefinitionBuilder withSupportedNicknameHourly() {
         return this;
     }
 
+    /**
+     * Supports cron nickname @reboot
+     *
+     * @return this CronDefinitionBuilder instance
+     */
+    public CronDefinitionBuilder withSupportedNicknameReboot() {
+        cronNicknames.add(CronNicknames.REBOOT);
+        return this;
+    }
+
     /**
      * Adds a cron validation.
      * @param validation - constraint validation

src/main/java/com/cronutils/model/definition/CronNicknames.java

@@ -1,5 +1,5 @@
 package com.cronutils.model.definition;
 
 public enum CronNicknames {
-    YEARLY, ANNUALLY, MONTHLY, WEEKLY, DAILY, MIDNIGHT, HOURLY;
+    YEARLY, ANNUALLY, MONTHLY, WEEKLY, DAILY, MIDNIGHT, HOURLY, REBOOT;
 }

src/main/java/com/cronutils/parser/CronParser.java

@@ -118,6 +118,8 @@ public Cron parse(final String expression) {
                     return validateAndReturnSupportedCronNickname(expression, cronNicknames, CronNicknames.MIDNIGHT, CronBuilder.midnight(cronDefinition));
                 case "@hourly":
                     return validateAndReturnSupportedCronNickname(expression, cronNicknames, CronNicknames.HOURLY, CronBuilder.hourly(cronDefinition));
+                case "@reboot":
+                    return validateAndReturnSupportedCronNickname(expression, cronNicknames, CronNicknames.REBOOT, CronBuilder.reboot(cronDefinition));
             }
         }
 

src/test/java/com/cronutils/model/definition/CronDefinitionBuilderTest.java

@@ -416,4 +416,11 @@ public void testSpring53ScheduleHourly(){
         CronParser parser = new CronParser(cronDefinition);
         parser.parse("@hourly");
     }
+
+    @Test
+    public void testScheduleReboot(){
+        CronDefinition cronDefinition = builder.withSupportedNicknameReboot().instance();
+        CronParser parser = new CronParser(cronDefinition);
+        parser.parse("@reboot");
+    }
 }