Add '.after' method

Author: dykov

readme.md

@@ -31,6 +31,7 @@
     *   [.reject](#reject)
     *   [.find](#find)
     *   [.reduce](#reduce)
+    *   [.after](#after)
 
 *   [How to contribute?](#how-to-contribute)
 
@@ -161,6 +162,29 @@ public interface Enumerable<X> extends Collection<X> {
     default X reduce(X idn, BinaryOperator<X> opr) {
         // ...
     }
+
+    /**
+     * Returns an enumerable containing all elements of enumerable
+     *  after the first one which corresponds the condition.
+     * If no predicate (null) is given, then 'this' is returned instead.
+     * @param prd The function to match element after which enumerable elements should be returned.
+     * @return The enumerable.
+     */
+    default Enumerable<X> after(Predicate<X> prd) {
+        // ...
+    }
+
+    /**
+     * Returns an enumerable containing a certain number of elements of enumerable
+     *  after the first one which corresponds the condition.
+     * If no predicate (null) is given, then 'this' is returned instead.
+     * @param prd The function to match element after which enumerable elements should be returned.
+     * @param size The number of elements the enumerable should be limited to.
+     * @return The enumerable.
+     */
+    default Enumerable<X> after(Predicate<X> prd, long size) {
+        // ...
+    }
 }
 ```
 See [more](./src/main/java/io/github/dgroup/enumerable4j/Enumerable.java).
@@ -200,6 +224,7 @@ See [more](./src/main/java/io/github/dgroup/enumerable4j/Enumerable.java).
     `.count(...)` | `.stream().filter(...).count()` | `new Filtered<>(...).size()` | tbd |
     `.find(...)` | `.stream().filter(...).findFirst().orElse(...)` | `new FirstOf<>(...,...).value()` | tbd |
     `.reduce(...,...)` | `.stream().reduce(...,...)` | `new Reduced<>(...,...).value()` | tbd |
+    `.after(...)` | | | tbd |
 
 #### .all
 
@@ -265,6 +290,14 @@ YourOwnCollection<Integer> src = ...                    // with elements [1, 2,
 Integer sum = src.reduce(0, Integer::sum);              // 6 
 ```
 
+#### .after
+
+```java
+YourOwnCollection<Integer> src = ...                                 // with elements [2, 3, 4, 5, 6]
+Enumerable<Integer> afterThree = src.after(val -> val == 3);         // [4, 5, 6] 
+Enumerable<Integer> firstTwoAfterThree = src.after(val -> val == 3, 2); // [4, 5]                
+```
+
 ### How to contribute?
 
 [![EO badge](http://www.elegantobjects.org/badge.svg)](http://www.elegantobjects.org/#principles)

src/main/java/io/github/dgroup/enumerable4j/Enumerable.java

@@ -42,6 +42,7 @@
  * @param <X> The type of entities.
  * @since 0.1.0
  */
+@SuppressWarnings("PMD.TooManyMethods")
 public interface Enumerable<X> extends Collection<X> {
 
     /**
@@ -210,4 +211,42 @@ default X reduce(X idn, BinaryOperator<X> opr) {
         }
         return res;
     }
+
+    /**
+     * Returns an enumerable containing all elements of enumerable
+     *  after the first one which corresponds the condition.
+     * If no predicate (null) is given, then 'this' is returned instead.
+     * @param prd The function to match element after which enumerable elements should be returned.
+     * @return The enumerable.
+     */
+    default Enumerable<X> after(Predicate<X> prd) {
+        return this.after(prd, this.size() - 1);
+    }
+
+    /**
+     * Returns an enumerable containing a certain number of elements of enumerable
+     *  after the first one which corresponds the condition.
+     * If no predicate (null) is given, then 'this' is returned instead.
+     * @param prd The function to match element after which enumerable elements should be returned.
+     * @param size The number of elements the enumerable should be limited to.
+     * @return The enumerable.
+     */
+    default Enumerable<X> after(Predicate<X> prd, long size) {
+        final Enumerable<X> out;
+        if (prd == null) {
+            out = this;
+        } else {
+            int skip = 0;
+            for (final X elem : this) {
+                ++skip;
+                if (prd.test(elem)) {
+                    break;
+                }
+            }
+            out = new Linked<>(
+                this.stream().skip(skip).limit(size).collect(Collectors.toList())
+            );
+        }
+        return out;
+    }
 }

src/test/java/io/github/dgroup/enumerable4j/AfterTest.java

@@ -0,0 +1,95 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2019-2021 Yurii Dubinka
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom
+ * the Software is  furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+ * OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package io.github.dgroup.enumerable4j;
+
+import org.junit.jupiter.api.Test;
+import org.llorllale.cactoos.matchers.Assertion;
+import org.llorllale.cactoos.matchers.HasValues;
+
+/**
+ * Test cases for {@link Enumerable#after}.
+ *
+ * @since 0.1.0
+ * @checkstyle MagicNumberCheck (500 lines)
+ * @checkstyle JavadocMethodCheck (500 lines)
+ */
+@SuppressWarnings("PMD.AvoidDuplicateLiterals")
+public final class AfterTest {
+
+    @Test
+    void nullPredicate() {
+        new Assertion<>(
+            "In case null-function the self enumerable is expected",
+            new Linked<>(1, 2, 3, 4).after(null),
+            new HasValues<>(1, 2, 3, 4)
+        ).affirm();
+    }
+
+    @Test
+    void allAfter() {
+        new Assertion<>(
+            "All elements after the first one which corresponds the condition",
+            new Linked<>(1, 2, 3, 4, 5, 6, 7).after(n -> n > 2),
+            new HasValues<>(4, 5, 6, 7)
+        ).affirm();
+    }
+
+    @Test
+    void firstThreeAfter() {
+        new Assertion<>(
+            "First 3 elements after the first one which corresponds the condition",
+            new Linked<>(1, 2, 3, 4, 5, 6, 7).after(n -> n > 2, 3),
+            new HasValues<>(4, 5, 6)
+        ).affirm();
+    }
+
+    @Test
+    void allStringsAfter() {
+        new Assertion<>(
+            "All string elements after the first one which corresponds the condition",
+            new Linked<>("a", "b", "c", "d", "e").after(s -> s.equals("c")),
+            new HasValues<>("d", "e")
+        ).affirm();
+    }
+
+    @Test
+    void firstTenAfter() {
+        new Assertion<>(
+            "The specified size can be greater than an actual enumerable size",
+            new Linked<>(1, 2, 3, 4, 5).after(n -> n == 3, 10),
+            new HasValues<>(4, 5)
+        ).affirm();
+    }
+
+    @Test
+    void allAfterFirst() {
+        new Assertion<>(
+            "The first element of enumerable corresponds the condition",
+            new Linked<>(1, 2, 3, 4, 5).after(n -> n < 10),
+            new HasValues<>(2, 3, 4, 5)
+        ).affirm();
+    }
+
+}