Add support for determining whether a set is infinite

build.gradle

@@ -77,6 +77,7 @@ dependencies {
     api 'org.dmfs:rfc5545-datetime:0.3'
     implementation 'org.dmfs:jems2:2.22.0'
     testImplementation project("lib-recur-hamcrest")
+    testImplementation project("lib-recur-confidence")
     testImplementation 'org.dmfs:jems2-testing:2.22.0'
     testImplementation 'org.saynotobugs:confidence-core:0.42.0'
 }

gradle/libs.versions.toml

@@ -0,0 +1,29 @@
+[versions]
+eclipse-jdt = "2.2.600"
+hamcrest = "2.2"
+jems2 = "2.22.0"
+junit = "5.8.2"
+junit-testkit = "1.9.2"
+srcless = "0.3.0"
+confidence = "0.42.0"
+
+[libraries]
+srcless-annotations = { module = "org.dmfs:srcless-annotations", version.ref = "srcless" }
+srcless-processors = { module = "org.dmfs:srcless-processors", version.ref = "srcless" }
+eclipse-jdt-anntation = { module = 'org.eclipse.jdt:org.eclipse.jdt.annotation', version.ref = "eclipse-jdt" }
+nullless-processors = { module = "org.dmfs:nullless-processors", version.ref = "srcless" }
+
+junit-jupiter-api = { module = "org.junit.jupiter:junit-jupiter-api", version.ref = "junit" }
+junit-jupiter-engine = { module = "org.junit.jupiter:junit-jupiter-engine", version.ref = "junit" }
+
+jems2 = { module = "org.dmfs:jems2", version.ref = "jems2" }
+jems2-testing = { module = "org.dmfs:jems2-testing", version.ref = "jems2" }
+jems2-confidence = { module = "org.dmfs:jems2-confidence", version.ref = "jems2" }
+
+confidence-core = { module = "org.saynotobugs:confidence-core", version.ref = "confidence" }
+confidence-test = { module = "org.saynotobugs:confidence-test", version.ref = "confidence" }
+
+[bundles]
+srcless-processors = ["srcless-processors", "nullless-processors"]
+
+[plugins]

lib-recur-confidence/build.gradle

@@ -0,0 +1,25 @@
+plugins {
+    id 'java-library'
+}
+
+sourceCompatibility = JavaVersion.VERSION_1_8
+targetCompatibility = JavaVersion.VERSION_1_8
+
+dependencies {
+    compileOnly libs.eclipse.jdt.anntation
+    compileOnly libs.srcless.annotations
+    annotationProcessor libs.bundles.srcless.processors
+    api libs.confidence.core
+    implementation libs.jems2
+    implementation libs.jems2.confidence
+    api rootProject
+
+    testImplementation libs.confidence.test
+    testImplementation libs.jems2.testing
+    testImplementation libs.junit.jupiter.api
+    testRuntimeOnly libs.junit.jupiter.engine
+}
+
+test {
+    useJUnitPlatform()
+}

lib-recur-confidence/src/main/java/org/dmfs/rfc5545/confidence/quality/EmptyRecurrenceSet.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2024 Marten Gajda <marten@dmfs.org>
+ *
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.dmfs.rfc5545.confidence.quality;
+
+import org.dmfs.jems2.confidence.optional.Absent;
+import org.dmfs.rfc5545.RecurrenceSet;
+import org.dmfs.srcless.annotations.staticfactory.StaticFactories;
+import org.saynotobugs.confidence.description.Text;
+import org.saynotobugs.confidence.quality.composite.AllOf;
+import org.saynotobugs.confidence.quality.composite.Has;
+import org.saynotobugs.confidence.quality.composite.Not;
+import org.saynotobugs.confidence.quality.composite.QualityComposition;
+import org.saynotobugs.confidence.quality.iterable.EmptyIterable;
+import org.saynotobugs.confidence.quality.object.Satisfies;
+
+@StaticFactories(value = "Recur", packageName = "org.dmfs.rfc5545.confidence")
+public final class EmptyRecurrenceSet extends QualityComposition<RecurrenceSet>
+{
+    public EmptyRecurrenceSet()
+    {
+        super(new AllOf<>(
+            new EmptyIterable(),
+            new Not<>(new Satisfies<>(RecurrenceSet::isInfinite, new Text("is infinite")))
+        ));
+    }
+}

lib-recur-confidence/src/main/java/org/dmfs/rfc5545/confidence/quality/Finite.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2024 Marten Gajda <marten@dmfs.org>
+ *
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.dmfs.rfc5545.confidence.quality;
+
+import org.dmfs.jems2.predicate.Not;
+import org.dmfs.rfc5545.RecurrenceSet;
+import org.dmfs.srcless.annotations.staticfactory.StaticFactories;
+import org.saynotobugs.confidence.description.Text;
+import org.saynotobugs.confidence.quality.composite.QualityComposition;
+import org.saynotobugs.confidence.quality.object.Satisfies;
+
+@StaticFactories(value = "Recur", packageName = "org.dmfs.rfc5545.confidence")
+public final class Finite extends QualityComposition<RecurrenceSet>
+{
+    public Finite()
+    {
+        super(new Satisfies<>(new Not<>(RecurrenceSet::isInfinite), new Text("finite")));
+    }
+}

lib-recur-confidence/src/main/java/org/dmfs/rfc5545/confidence/quality/Infinite.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2024 Marten Gajda <marten@dmfs.org>
+ *
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.dmfs.rfc5545.confidence.quality;
+
+import org.dmfs.rfc5545.RecurrenceSet;
+import org.dmfs.srcless.annotations.staticfactory.StaticFactories;
+import org.saynotobugs.confidence.description.Text;
+import org.saynotobugs.confidence.quality.composite.QualityComposition;
+import org.saynotobugs.confidence.quality.object.Satisfies;
+
+@StaticFactories(value = "Recur", packageName = "org.dmfs.rfc5545.confidence")
+public final class Infinite extends QualityComposition<RecurrenceSet>
+{
+    public Infinite()
+    {
+        super(new Satisfies<>(RecurrenceSet::isInfinite, new Text("infinite")));
+    }
+}

lib-recur-confidence/src/main/java/org/dmfs/rfc5545/confidence/quality/StartsWith.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2024 Marten Gajda <marten@dmfs.org>
+ *
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.dmfs.rfc5545.confidence.quality;
+
+import org.dmfs.jems2.iterable.First;
+import org.dmfs.rfc5545.DateTime;
+import org.dmfs.rfc5545.RecurrenceSet;
+import org.dmfs.srcless.annotations.staticfactory.StaticFactories;
+import org.saynotobugs.confidence.quality.composite.Has;
+import org.saynotobugs.confidence.quality.composite.QualityComposition;
+import org.saynotobugs.confidence.quality.iterable.Iterates;
+
+@StaticFactories(value = "Recur", packageName = "org.dmfs.rfc5545.confidence")
+public final class StartsWith extends QualityComposition<RecurrenceSet>
+{
+    public StartsWith(DateTime... instances)
+    {
+        super(new Has<>("first " + instances.length + " instances",
+            candidate -> new First<>(instances.length, candidate), new Iterates<>(instances)));
+    }
+}

lib-recur-confidence/src/test/java/org/dmfs/rfc5545/confidence/quality/EmptyRecurrenceSetTest.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2024 Marten Gajda <marten@dmfs.org>
+ *
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.dmfs.rfc5545.confidence.quality;
+
+import org.dmfs.rfc5545.RecurrenceSet;
+import org.dmfs.rfc5545.instanceiterator.EmptyIterator;
+import org.junit.jupiter.api.Test;
+
+import static org.dmfs.jems2.mockito.Mock.*;
+import static org.saynotobugs.confidence.Assertion.assertThat;
+import static org.saynotobugs.confidence.quality.Core.allOf;
+
+class EmptyRecurrenceSetTest
+{
+    @Test
+    void test()
+    {
+        assertThat(new EmptyRecurrenceSet(),
+            allOf(
+                org.saynotobugs.confidence.test.quality.Test.<RecurrenceSet>passes(mock(RecurrenceSet.class,
+                    with(RecurrenceSet::isInfinite, returning(false)),
+                    with(RecurrenceSet::iterator, returning(new EmptyIterator())))),
+                org.saynotobugs.confidence.test.quality.Test.<RecurrenceSet>fails(mock(RecurrenceSet.class,
+                    with(RecurrenceSet::isInfinite, returning(true)),
+                    with(RecurrenceSet::iterator, returning(new EmptyIterator()))))));
+    }
+
+}

settings.gradle

@@ -1,4 +1,5 @@
 rootProject.name = 'lib-recur'
+include 'lib-recur-confidence'
 include 'lib-recur-hamcrest'
 include 'benchmark'
 

src/main/java/org/dmfs/rfc5545/RecurrenceSet.java

@@ -18,6 +18,8 @@
 package org.dmfs.rfc5545;
 
 
+import org.dmfs.jems2.Optional;
+
 /**
  * A set of instances.
  */
@@ -27,4 +29,9 @@ public interface RecurrenceSet extends Iterable<DateTime>
      * Returns an {@link InstanceIterator} for this {@link RecurrenceSet}.
      */
     InstanceIterator iterator();
+
+    /**
+     * Returns whether this {@link RecurrenceSet} is infinite or not.
+     */
+    boolean isInfinite();
 }

src/main/java/org/dmfs/rfc5545/recurrenceset/FastForwarded.java

@@ -57,4 +57,10 @@ public InstanceIterator iterator()
         iterator.fastForward(mTimeStamp);
         return iterator;
     }
+
+    @Override
+    public boolean isInfinite()
+    {
+        return mDelegate.isInfinite();
+    }
 }

src/main/java/org/dmfs/rfc5545/recurrenceset/FromList.java

@@ -87,4 +87,10 @@ public InstanceIterator iterator()
             ? new FastForwardable(delegate.next(), delegate.hasNext() ? delegate : EmptyIterator.INSTANCE)
             : EmptyIterator.INSTANCE;
     }
+
+    @Override
+    public boolean isInfinite()
+    {
+        return false;
+    }
 }

src/main/java/org/dmfs/rfc5545/recurrenceset/FromRule.java

@@ -41,4 +41,11 @@ public InstanceIterator iterator()
     {
         return mRecurrenceRule.iterator(mFirstInstance);
     }
+
+    @Override
+    public boolean isInfinite()
+    {
+        return mRecurrenceRule.isInfinite();
+    }
+
 }

src/main/java/org/dmfs/rfc5545/recurrenceset/FromRuleIncludingStart.java

@@ -20,8 +20,8 @@
 import org.dmfs.rfc5545.DateTime;
 import org.dmfs.rfc5545.InstanceIterator;
 import org.dmfs.rfc5545.RecurrenceSet;
-import org.dmfs.rfc5545.instanceiterator.Merged;
 import org.dmfs.rfc5545.instanceiterator.CountLimitedRecurrenceRuleIterator;
+import org.dmfs.rfc5545.instanceiterator.Merged;
 import org.dmfs.rfc5545.recur.RecurrenceRule;
 import org.dmfs.rfc5545.recur.RecurrenceRuleIterator;
 
@@ -61,4 +61,11 @@ public InstanceIterator iterator()
         }
         return ruleIterator;
     }
+
+    @Override
+    public boolean isInfinite()
+    {
+        return mRecurrenceRule.isInfinite();
+    }
+
 }

src/main/java/org/dmfs/rfc5545/recurrenceset/FromRules.java

@@ -56,4 +56,11 @@ public InstanceIterator iterator()
     {
         return mDelegate.iterator();
     }
+
+    @Override
+    public boolean isInfinite()
+    {
+        return mDelegate.isInfinite();
+    }
+
 }