From 02162994a30c500518bf2c9e199b2ee80dfc6f2c Mon Sep 17 00:00:00 2001 From: Hannes Pernpeintner Date: Mon, 17 Aug 2015 03:54:37 +0200 Subject: [PATCH 01/12] #184 Fluent Interface pattern --- fluentinterface/pom.xml | 20 ++ .../com/iluwatar/fluentinterface/App.java | 90 ++++++++ .../fluentiterable/FluentIterable.java | 192 ++++++++++++++++++ .../com/iluwatar/fluentinterface/AppTest.java | 12 ++ pom.xml | 3 +- 5 files changed, 316 insertions(+), 1 deletion(-) create mode 100644 fluentinterface/pom.xml create mode 100644 fluentinterface/src/main/java/com/iluwatar/fluentinterface/App.java create mode 100644 fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/FluentIterable.java create mode 100644 fluentinterface/src/test/java/com/iluwatar/fluentinterface/AppTest.java diff --git a/fluentinterface/pom.xml b/fluentinterface/pom.xml new file mode 100644 index 000000000..c78c182e3 --- /dev/null +++ b/fluentinterface/pom.xml @@ -0,0 +1,20 @@ + + + + java-design-patterns + com.iluwatar + 1.5.0 + + 4.0.0 + + fluentinterface + + + junit + junit + test + + + \ No newline at end of file diff --git a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/App.java b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/App.java new file mode 100644 index 000000000..fded13624 --- /dev/null +++ b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/App.java @@ -0,0 +1,90 @@ +package com.iluwatar.fluentinterface; + +import com.iluwatar.fluentinterface.fluentiterable.FluentIterable; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import java.util.StringJoiner; +import java.util.function.Function; +import java.util.function.Predicate; + +public class App { + + public static void main(String[] args) { + + List integerList = new ArrayList() {{ + add(1); + add(-61); + add(14); + add(-22); + add(18); + add(-87); + add(6); + add(64); + add(-82); + add(26); + add(-98); + add(97); + add(45); + add(23); + add(2); + add(-68); + add(45); + }}; + prettyPrint("The initial list contains: ", integerList); + + List firstFiveNegatives = FluentIterable.from(integerList) + .filter(negatives()) + .first(3) + .asList(); + prettyPrint("The first three negative values are: ", firstFiveNegatives); + + + List lastTwoPositives = FluentIterable.from(integerList) + .filter(positives()) + .last(2) + .asList(); + prettyPrint("The last two positive values are: ", lastTwoPositives); + + FluentIterable.from(integerList) + .filter(number -> number%2 == 0) + .first() + .ifPresent(evenNumber -> System.out.println(String.format("The first even number is: %d", evenNumber))); + + + List transformedList = FluentIterable.from(integerList) + .filter(negatives()) + .map(transformToString()) + .asList(); + prettyPrint("A string-mapped list of negative numbers contains: ", transformedList); + + } + + private static Function transformToString() { + return integer -> "String[" + String.valueOf(integer) + "]"; + } + private static Predicate negatives() { + return integer -> (integer < 0); + } + private static Predicate positives() { + return integer -> (integer > 0); + } + + private static void prettyPrint(String prefix, Iterable iterable) { + prettyPrint(", ", prefix, ".", iterable); + } + private static void prettyPrint(String prefix, String suffix, Iterable iterable) { + prettyPrint(", ", prefix, suffix, iterable); + } + + private static void prettyPrint(String delimiter, String prefix, String suffix, Iterable iterable) { + StringJoiner joiner = new StringJoiner(delimiter, prefix, "."); + Iterator iterator = iterable.iterator(); + while (iterator.hasNext()) { + joiner.add(iterator.next().toString()); + } + + System.out.println(joiner); + } +} diff --git a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/FluentIterable.java b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/FluentIterable.java new file mode 100644 index 000000000..edb9275c1 --- /dev/null +++ b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/FluentIterable.java @@ -0,0 +1,192 @@ +package com.iluwatar.fluentinterface.fluentiterable; + +import java.util.*; +import java.util.function.Consumer; +import java.util.function.Function; +import java.util.function.Predicate; + +/** + * The FluentIterable is a more convenient implementation of the common iterable interface based + * on the fluent interface design pattern. + * This implementation demonstrates a possible way to implement this functionality, but + * doesn't aim to be complete. It was inspired by Guava's com.google.common.collect.FluentIterable. + * @param is the class of objects the iterable contains + */ +public class FluentIterable implements Iterable { + + private final Iterable iterable; + + /** + * This constructor creates a copy of a given iterable's contents. + * @param iterable the iterable this interface copies to work on. + */ + protected FluentIterable(Iterable iterable) { + ArrayList copy = new ArrayList<>(); + Iterator iterator = iterable.iterator(); + while (iterator.hasNext()) { + copy.add(iterator.next()); + } + this.iterable = copy; + } + + /** + * Iterates over all elements of this iterator and filters them. + * @param predicate the condition to test with for the filtering. If the test + * is negative, the tested object is removed by the iterator. + * @return the same FluentIterable with a filtered collection + */ + public final FluentIterable filter(Predicate predicate) { + Iterator iterator = iterator(); + while (iterator.hasNext()) { + TYPE nextElement = iterator.next(); + if(!predicate.test(nextElement)) { + iterator.remove(); + } + } + return this; + } + + /** + * Uses the Iterable interface's forEach method to apply a given function + * for each object of the iterator. + * @param action the action for each object + * @return the same FluentIterable with an untouched collection + */ + public final FluentIterable forEachDo(Consumer action) { + iterable.forEach(action); + return this; + } + + /** + * Can be used to collect objects from the iteration. + * @return an option of the first object of the iteration + */ + public final Optional first() { + List list = first(1).asList(); + if(list.isEmpty()) { + return Optional.empty(); + } + return Optional.of(list.get(0)); + } + + /** + * Can be used to collect objects from the iteration. + * @param count defines the number of objects to return + * @return the same FluentIterable with a collection decimated to a maximum of 'count' first objects. + */ + public final FluentIterable first(int count) { + Iterator iterator = iterator(); + int currentCount = 0; + while (iterator.hasNext()) { + iterator.next(); + if(currentCount >= count) { + iterator.remove(); + } + currentCount++; + } + return this; + } + + /** + * Can be used to collect objects from the iteration. + * @return an option of the last object of the iteration + */ + public final Optional last() { + List list = last(1).asList(); + if(list.isEmpty()) { + return Optional.empty(); + } + return Optional.of(list.get(0)); + } + + /** + * Can be used to collect objects from the iteration. + * @param count defines the number of objects to return + * @return the same FluentIterable with a collection decimated to a maximum of 'count' last objects + */ + public final FluentIterable last(int count) { + int remainingElementsCount = getRemainingElementsCount(); + Iterator iterator = iterator(); + int currentIndex = 0; + while (iterator.hasNext()) { + iterator.next(); + if(currentIndex < remainingElementsCount - count) { + iterator.remove(); + } + currentIndex++; + } + + return this; + } + + /** + * Transforms this FluentIterable into a new one containing objects of the type NEW_TYPE. + * @param function a function that transforms an instance of TYPE into an instance of NEW_TYPE + * @param the target type of the transformation + * @return a new FluentIterable of the new type + */ + public final FluentIterable map(Function function) { + List temporaryList = new ArrayList(); + Iterator iterator = iterator(); + while (iterator.hasNext()) { + temporaryList.add(function.apply(iterator.next())); + } + return from(temporaryList); + } + + /** + * Collects all remaining objects of this iteration into a list. + * @return a list with all remaining objects of this iteration + */ + public List asList() { + return toList(iterable.iterator()); + } + + /** + * @return a FluentIterable from a given iterable. Calls the FluentIterable constructor. + */ + public static final FluentIterable from(Iterable iterable) { + return new FluentIterable<>(iterable); + } + + @Override + public Iterator iterator() { + return iterable.iterator(); + } + + @Override + public void forEach(Consumer action) { + iterable.forEach(action); + } + + + @Override + public Spliterator spliterator() { + return iterable.spliterator(); + } + + /** + * @return the count of remaining objects in the current iteration + */ + public final int getRemainingElementsCount() { + int counter = 0; + Iterator iterator = iterator(); + while(iterator.hasNext()) { + iterator.next(); + counter++; + } + return counter; + } + + /** + * Collects the remaining objects of the given iterators iteration into an List. + * @return a new List with the remaining objects. + */ + public static List toList(Iterator iterator) { + List copy = new ArrayList<>(); + while (iterator.hasNext()) { + copy.add(iterator.next()); + } + return copy; + } +} diff --git a/fluentinterface/src/test/java/com/iluwatar/fluentinterface/AppTest.java b/fluentinterface/src/test/java/com/iluwatar/fluentinterface/AppTest.java new file mode 100644 index 000000000..32bbca430 --- /dev/null +++ b/fluentinterface/src/test/java/com/iluwatar/fluentinterface/AppTest.java @@ -0,0 +1,12 @@ +package com.iluwatar.fluentinterface; + +import org.junit.Test; + +public class AppTest { + + @Test + public void test() { + String[] args = {}; + App.main(args); + } +} diff --git a/pom.xml b/pom.xml index 7b0d80bd8..2c040005b 100644 --- a/pom.xml +++ b/pom.xml @@ -77,7 +77,8 @@ step-builder layers message-channel - + fluentinterface + From ded21b70acdbfa746343a0ebd6e5d33c5bf37dfb Mon Sep 17 00:00:00 2001 From: Hannes Pernpeintner Date: Sat, 22 Aug 2015 20:22:00 +0200 Subject: [PATCH 02/12] #184 Fluent interface pattern, lazy fluentiterable added --- .../com/iluwatar/fluentinterface/App.java | 34 ++- .../fluentiterable/FluentIterable.java | 175 +++---------- .../lazy/DecoratingIterator.java | 53 ++++ .../lazy/LazyFluentIterable.java | 236 ++++++++++++++++++ .../simple/SimpleFluentIterable.java | 194 ++++++++++++++ 5 files changed, 539 insertions(+), 153 deletions(-) create mode 100644 fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/DecoratingIterator.java create mode 100644 fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/LazyFluentIterable.java create mode 100644 fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/simple/SimpleFluentIterable.java diff --git a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/App.java b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/App.java index fded13624..96a2db323 100644 --- a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/App.java +++ b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/App.java @@ -1,14 +1,14 @@ package com.iluwatar.fluentinterface; -import com.iluwatar.fluentinterface.fluentiterable.FluentIterable; +import com.iluwatar.fluentinterface.fluentiterable.lazy.LazyFluentIterable; +import com.iluwatar.fluentinterface.fluentiterable.simple.SimpleFluentIterable; -import java.util.ArrayList; -import java.util.Iterator; -import java.util.List; -import java.util.StringJoiner; +import java.util.*; import java.util.function.Function; import java.util.function.Predicate; +import static java.lang.String.valueOf; + public class App { public static void main(String[] args) { @@ -34,35 +34,49 @@ public class App { }}; prettyPrint("The initial list contains: ", integerList); - List firstFiveNegatives = FluentIterable.from(integerList) + List firstFiveNegatives = SimpleFluentIterable.from(integerList) .filter(negatives()) .first(3) .asList(); prettyPrint("The first three negative values are: ", firstFiveNegatives); - List lastTwoPositives = FluentIterable.from(integerList) + List lastTwoPositives = SimpleFluentIterable.from(integerList) .filter(positives()) .last(2) .asList(); prettyPrint("The last two positive values are: ", lastTwoPositives); - FluentIterable.from(integerList) + SimpleFluentIterable.from(integerList) .filter(number -> number%2 == 0) .first() .ifPresent(evenNumber -> System.out.println(String.format("The first even number is: %d", evenNumber))); - List transformedList = FluentIterable.from(integerList) + List transformedList = SimpleFluentIterable.from(integerList) .filter(negatives()) .map(transformToString()) .asList(); prettyPrint("A string-mapped list of negative numbers contains: ", transformedList); + + List lastTwoOfFirstFourStringMapped = LazyFluentIterable.from(integerList) + .filter(positives()) + .first(4) + .last(2) + .map(number -> "String[" + String.valueOf(number) + "]") + .asList(); + prettyPrint("The lazy list contains the last two of the first four positive numbers mapped to Strings: ", lastTwoOfFirstFourStringMapped); + + LazyFluentIterable.from(integerList) + .filter(negatives()) + .first(2) + .last() + .ifPresent(lastOfFirstTwo -> System.out.println(String.format("The last of the first two negatives is: %d", lastOfFirstTwo))); } private static Function transformToString() { - return integer -> "String[" + String.valueOf(integer) + "]"; + return integer -> "String[" + valueOf(integer) + "]"; } private static Predicate negatives() { return integer -> (integer < 0); diff --git a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/FluentIterable.java b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/FluentIterable.java index edb9275c1..7bdaf274c 100644 --- a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/FluentIterable.java +++ b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/FluentIterable.java @@ -1,6 +1,9 @@ package com.iluwatar.fluentinterface.fluentiterable; -import java.util.*; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import java.util.Optional; import java.util.function.Consumer; import java.util.function.Function; import java.util.function.Predicate; @@ -8,116 +11,49 @@ import java.util.function.Predicate; /** * The FluentIterable is a more convenient implementation of the common iterable interface based * on the fluent interface design pattern. - * This implementation demonstrates a possible way to implement this functionality, but + * This interface defines common operations, but * doesn't aim to be complete. It was inspired by Guava's com.google.common.collect.FluentIterable. * @param is the class of objects the iterable contains */ -public class FluentIterable implements Iterable { - - private final Iterable iterable; +public interface FluentIterable extends Iterable { /** - * This constructor creates a copy of a given iterable's contents. - * @param iterable the iterable this interface copies to work on. - */ - protected FluentIterable(Iterable iterable) { - ArrayList copy = new ArrayList<>(); - Iterator iterator = iterable.iterator(); - while (iterator.hasNext()) { - copy.add(iterator.next()); - } - this.iterable = copy; - } - - /** - * Iterates over all elements of this iterator and filters them. + * Filters the iteration with the given predicate. * @param predicate the condition to test with for the filtering. If the test * is negative, the tested object is removed by the iterator. - * @return the same FluentIterable with a filtered collection + * @return a filtered FluentIterable */ - public final FluentIterable filter(Predicate predicate) { - Iterator iterator = iterator(); - while (iterator.hasNext()) { - TYPE nextElement = iterator.next(); - if(!predicate.test(nextElement)) { - iterator.remove(); - } - } - return this; - } + FluentIterable filter(Predicate predicate); /** * Uses the Iterable interface's forEach method to apply a given function - * for each object of the iterator. - * @param action the action for each object - * @return the same FluentIterable with an untouched collection + * for each object of the iterator. This is a terminating operation. */ - public final FluentIterable forEachDo(Consumer action) { - iterable.forEach(action); - return this; - } + void forEachDo(Consumer action); /** - * Can be used to collect objects from the iteration. - * @return an option of the first object of the iteration + * Evaluates the iteration and returns the first element. This is a terminating operation. + * @return the first element after the iteration is evaluated */ - public final Optional first() { - List list = first(1).asList(); - if(list.isEmpty()) { - return Optional.empty(); - } - return Optional.of(list.get(0)); - } + Optional first(); /** - * Can be used to collect objects from the iteration. - * @param count defines the number of objects to return - * @return the same FluentIterable with a collection decimated to a maximum of 'count' first objects. + * Evaluates the iteration and leaves only the count first elements. + * @return the first count elements as an Iterable */ - public final FluentIterable first(int count) { - Iterator iterator = iterator(); - int currentCount = 0; - while (iterator.hasNext()) { - iterator.next(); - if(currentCount >= count) { - iterator.remove(); - } - currentCount++; - } - return this; - } + FluentIterable first(int count); /** - * Can be used to collect objects from the iteration. - * @return an option of the last object of the iteration + * Evaluates the iteration and returns the last element. This is a terminating operation. + * @return the last element after the iteration is evaluated */ - public final Optional last() { - List list = last(1).asList(); - if(list.isEmpty()) { - return Optional.empty(); - } - return Optional.of(list.get(0)); - } + Optional last(); /** - * Can be used to collect objects from the iteration. - * @param count defines the number of objects to return - * @return the same FluentIterable with a collection decimated to a maximum of 'count' last objects + * Evaluates the iteration and leaves only the count last elements. + * @return the last counts elements as an Iterable */ - public final FluentIterable last(int count) { - int remainingElementsCount = getRemainingElementsCount(); - Iterator iterator = iterator(); - int currentIndex = 0; - while (iterator.hasNext()) { - iterator.next(); - if(currentIndex < remainingElementsCount - count) { - iterator.remove(); - } - currentIndex++; - } - - return this; - } + FluentIterable last(int count); /** * Transforms this FluentIterable into a new one containing objects of the type NEW_TYPE. @@ -125,65 +61,18 @@ public class FluentIterable implements Iterable { * @param the target type of the transformation * @return a new FluentIterable of the new type */ - public final FluentIterable map(Function function) { - List temporaryList = new ArrayList(); - Iterator iterator = iterator(); - while (iterator.hasNext()) { - temporaryList.add(function.apply(iterator.next())); - } - return from(temporaryList); - } + FluentIterable map(Function function); + List asList(); /** - * Collects all remaining objects of this iteration into a list. - * @return a list with all remaining objects of this iteration + * Utility method that iterates over iterable and adds the contents to a list. + * @param iterable the iterable to collect + * @param the type of the objects to iterate + * @return a list with all objects of the given iterator */ - public List asList() { - return toList(iterable.iterator()); - } - - /** - * @return a FluentIterable from a given iterable. Calls the FluentIterable constructor. - */ - public static final FluentIterable from(Iterable iterable) { - return new FluentIterable<>(iterable); - } - - @Override - public Iterator iterator() { - return iterable.iterator(); - } - - @Override - public void forEach(Consumer action) { - iterable.forEach(action); - } - - - @Override - public Spliterator spliterator() { - return iterable.spliterator(); - } - - /** - * @return the count of remaining objects in the current iteration - */ - public final int getRemainingElementsCount() { - int counter = 0; - Iterator iterator = iterator(); - while(iterator.hasNext()) { - iterator.next(); - counter++; - } - return counter; - } - - /** - * Collects the remaining objects of the given iterators iteration into an List. - * @return a new List with the remaining objects. - */ - public static List toList(Iterator iterator) { - List copy = new ArrayList<>(); + static List copyToList(Iterable iterable) { + ArrayList copy = new ArrayList<>(); + Iterator iterator = iterable.iterator(); while (iterator.hasNext()) { copy.add(iterator.next()); } diff --git a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/DecoratingIterator.java b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/DecoratingIterator.java new file mode 100644 index 000000000..0e5b410cc --- /dev/null +++ b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/DecoratingIterator.java @@ -0,0 +1,53 @@ +package com.iluwatar.fluentinterface.fluentiterable.lazy; + +import java.util.Iterator; + +/** + * This class is used to realize LazyFluentIterables. It decorates + * a given iterator. + * @param + */ +public abstract class DecoratingIterator implements Iterator { + + protected final Iterator fromIterator; + + private TYPE next = null; + + /** + * Creates an iterator that decorates the given iterator. + * @param fromIterator + */ + public DecoratingIterator(Iterator fromIterator) { + this.fromIterator = fromIterator; + } + + /** + * Precomputes and caches the next element of the iteration. + * @return true if a next element is available + */ + @Override + public final boolean hasNext() { + next = computeNext(); + return next != null; + } + + /** + * Returns the next element of the iteration. This implementation caches it. + * If no next element is cached, it is computed. + * @return the next element obf the iteration + */ + @Override + public final TYPE next() { + TYPE result = next; + next = null; + result = (result == null ? fromIterator.next() : result); + return result; + } + + /** + * Computes the next object of the iteration. Can be implemented to + * realize custom behaviour for an iteration process. + * @return + */ + public abstract TYPE computeNext(); +} diff --git a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/LazyFluentIterable.java b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/LazyFluentIterable.java new file mode 100644 index 000000000..c6db4d2cd --- /dev/null +++ b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/LazyFluentIterable.java @@ -0,0 +1,236 @@ +package com.iluwatar.fluentinterface.fluentiterable.lazy; + +import com.iluwatar.fluentinterface.fluentiterable.FluentIterable; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import java.util.Optional; +import java.util.function.Consumer; +import java.util.function.Function; +import java.util.function.Predicate; + +/** + * This is a lazy implementation of the FluentIterable interface. It evaluates + * all chained operations when a terminating operation is applied. + * @param the type of the objects the iteration is about + */ +public class LazyFluentIterable implements FluentIterable { + + private final Iterable iterable; + + /** + * This constructor creates a new LazyFluentIterable. It wraps the + * given iterable. + * @param iterable the iterable this FluentIterable works on. + */ + protected LazyFluentIterable(Iterable iterable) { + this.iterable = iterable; + } + + /** + * This constructor can be used to implement anonymous subclasses + * of the LazyFluentIterable. + */ + protected LazyFluentIterable() { + iterable = this; + } + + /** + * Adds a filter operation to the operation chain and returns a new iterable. + * @param predicate the condition to test with for the filtering. If the test + * is negative, the tested object is removed by the iterator. + * @return a new FluentIterable object that decorates the source iterable + */ + @Override + public FluentIterable filter(Predicate predicate) { + return new LazyFluentIterable() { + @Override + public Iterator iterator() { + return new DecoratingIterator(iterable.iterator()) { + @Override + public TYPE computeNext() { + while(true) { + if(fromIterator.hasNext()) { + TYPE candidate = fromIterator.next(); + if(!predicate.test(candidate)) { + continue; + } + return candidate; + } + + return null; + } + } + }; + } + }; + } + + /** + * Uses the Iterable interface's forEach method to apply a given function + * for each object of the iterator. Is a terminating operation. + * @param action the action for each object + */ + @Override + public void forEachDo(Consumer action) { + Iterator newIterator = iterable.iterator(); + while(newIterator.hasNext()) { + action.accept(newIterator.next()); + } + } + + /** + * Can be used to collect objects from the iteration. Is a terminating operation. + * @return an option of the first object of the iteration + */ + @Override + public Optional first() { + Optional result = Optional.empty(); + List list = first(1).asList(); + if(!list.isEmpty()) { + result = Optional.of(list.get(0)); + } + + return result; + } + + /** + * Can be used to collect objects from the iteration. Is a terminating operation. + * @param count defines the number of objects to return + * @return the same FluentIterable with a collection decimated to a maximum of 'count' first objects. + */ + @Override + public FluentIterable first(int count) { + return new LazyFluentIterable() { + @Override + public Iterator iterator() { + return new DecoratingIterator(iterable.iterator()) { + int currentIndex = 0; + + @Override + public TYPE computeNext() { + if(currentIndex < count) { + if(fromIterator.hasNext()) { + TYPE candidate = fromIterator.next(); + currentIndex++; + return candidate; + } + } + return null; + } + }; + } + }; + } + + /** + * Can be used to collect objects from the iteration. Is a terminating operation. + * @return an option of the last object of the iteration + */ + @Override + public Optional last() { + Optional result = Optional.empty(); + List list = last(1).asList(); + if(!list.isEmpty()) { + result = Optional.of(list.get(0)); + } + + return result; + } + + /** + * Can be used to collect objects from the iteration. Is a terminating operation. + * @param count defines the number of objects to return + * @return the same FluentIterable with a collection decimated to a maximum of 'count' last objects + */ + @Override + public FluentIterable last(int count) {return new LazyFluentIterable() { + @Override + public Iterator iterator() { + return new DecoratingIterator(iterable.iterator()) { + int currentIndex = 0; + + @Override + public TYPE computeNext() { + List list = new ArrayList<>(); + + Iterator newIterator = iterable.iterator(); + while(newIterator.hasNext()) { + list.add(newIterator.next()); + } + + int totalElementsCount = list.size(); + int stopIndex = totalElementsCount - count; + + TYPE candidate = null; + while(currentIndex < stopIndex && fromIterator.hasNext()) { + currentIndex++; + fromIterator.next(); + } + if(currentIndex >= stopIndex && fromIterator.hasNext()) { + candidate = fromIterator.next(); + } + return candidate; + } + }; + } + }; + } + + /** + * Transforms this FluentIterable into a new one containing objects of the type NEW_TYPE. + * @param function a function that transforms an instance of TYPE into an instance of NEW_TYPE + * @param the target type of the transformation + * @return a new FluentIterable of the new type + */ + @Override + public FluentIterable map(Function function) { + return new LazyFluentIterable() { + @Override + public Iterator iterator() { + return new DecoratingIterator(null) { + Iterator oldTypeIterator = iterable.iterator(); + @Override + public NEW_TYPE computeNext() { + while(true) { + if(oldTypeIterator.hasNext()) { + TYPE candidate = oldTypeIterator.next(); + return function.apply(candidate); + } + return null; + } + } + }; + } + }; + } + + /** + * Collects all remaining objects of this iteration into a list. + * @return a list with all remaining objects of this iteration + */ + @Override + public List asList() { + List copy = FluentIterable.copyToList(iterable); + return copy; + } + + @Override + public Iterator iterator() { + return new DecoratingIterator(iterable.iterator()) { + @Override + public TYPE computeNext() { + return fromIterator.next(); + } + }; + } + + /** + * @return a FluentIterable from a given iterable. Calls the LazyFluentIterable constructor. + */ + public static final FluentIterable from(Iterable iterable) { + return new LazyFluentIterable<>(iterable); + } + +} diff --git a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/simple/SimpleFluentIterable.java b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/simple/SimpleFluentIterable.java new file mode 100644 index 000000000..efaa87bbb --- /dev/null +++ b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/simple/SimpleFluentIterable.java @@ -0,0 +1,194 @@ +package com.iluwatar.fluentinterface.fluentiterable.simple; + +import com.iluwatar.fluentinterface.fluentiterable.FluentIterable; + +import java.util.*; +import java.util.function.Consumer; +import java.util.function.Function; +import java.util.function.Predicate; + +/** + * This is a simple implementation of the FluentIterable interface. It evaluates + * all chained operations eagerly. + * @param the type of the objects the iteration is about + */ +public class SimpleFluentIterable implements FluentIterable { + + private final Iterable iterable; + + /** + * This constructor creates a copy of a given iterable's contents. + * @param iterable the iterable this interface copies to work on. + */ + protected SimpleFluentIterable(Iterable iterable) { + List copy = FluentIterable.copyToList(iterable); + this.iterable = copy; + } + + /** + * Iterates over all elements of this iterator and filters them. + * @param predicate the condition to test with for the filtering. If the test + * is negative, the tested object is removed by the iterator. + * @return the same FluentIterable with a filtered collection + */ + @Override + public final FluentIterable filter(Predicate predicate) { + Iterator iterator = iterator(); + while (iterator.hasNext()) { + TYPE nextElement = iterator.next(); + if(!predicate.test(nextElement)) { + iterator.remove(); + } + } + return this; + } + + /** + * Uses the Iterable interface's forEach method to apply a given function + * for each object of the iterator. Is a terminating operation. + * @param action the action for each object + */ + @Override + public void forEachDo(Consumer action) { + iterable.forEach(action); + } + + /** + * Can be used to collect objects from the iteration. Is a terminating operation. + * @return an option of the first object of the iteration + */ + @Override + public final Optional first() { + List list = first(1).asList(); + if(list.isEmpty()) { + return Optional.empty(); + } + return Optional.of(list.get(0)); + } + + /** + * Can be used to collect objects from the iteration. Is a terminating operation. + * @param count defines the number of objects to return + * @return the same FluentIterable with a collection decimated to a maximum of 'count' first objects. + */ + @Override + public final FluentIterable first(int count) { + Iterator iterator = iterator(); + int currentCount = 0; + while (iterator.hasNext()) { + iterator.next(); + if(currentCount >= count) { + iterator.remove(); + } + currentCount++; + } + return this; + } + + /** + * Can be used to collect objects from the iteration. Is a terminating operation. + * @return an option of the last object of the iteration + */ + @Override + public final Optional last() { + List list = last(1).asList(); + if(list.isEmpty()) { + return Optional.empty(); + } + return Optional.of(list.get(0)); + } + + /** + * Can be used to collect objects from the iteration. Is a terminating operation. + * @param count defines the number of objects to return + * @return the same FluentIterable with a collection decimated to a maximum of 'count' last objects + */ + @Override + public final FluentIterable last(int count) { + int remainingElementsCount = getRemainingElementsCount(); + Iterator iterator = iterator(); + int currentIndex = 0; + while (iterator.hasNext()) { + iterator.next(); + if(currentIndex < remainingElementsCount - count) { + iterator.remove(); + } + currentIndex++; + } + + return this; + } + + /** + * Transforms this FluentIterable into a new one containing objects of the type NEW_TYPE. + * @param function a function that transforms an instance of TYPE into an instance of NEW_TYPE + * @param the target type of the transformation + * @return a new FluentIterable of the new type + */ + @Override + public final FluentIterable map(Function function) { + List temporaryList = new ArrayList(); + Iterator iterator = iterator(); + while (iterator.hasNext()) { + temporaryList.add(function.apply(iterator.next())); + } + return from(temporaryList); + } + + /** + * Collects all remaining objects of this iteration into a list. + * @return a list with all remaining objects of this iteration + */ + @Override + public List asList() { + return toList(iterable.iterator()); + } + + /** + * @return a FluentIterable from a given iterable. Calls the SimpleFluentIterable constructor. + */ + public static final FluentIterable from(Iterable iterable) { + return new SimpleFluentIterable<>(iterable); + } + + @Override + public Iterator iterator() { + return iterable.iterator(); + } + + @Override + public void forEach(Consumer action) { + iterable.forEach(action); + } + + + @Override + public Spliterator spliterator() { + return iterable.spliterator(); + } + + /** + * @return the count of remaining objects in the current iteration + */ + public final int getRemainingElementsCount() { + int counter = 0; + Iterator iterator = iterator(); + while(iterator.hasNext()) { + iterator.next(); + counter++; + } + return counter; + } + + /** + * Collects the remaining objects of the given iterators iteration into an List. + * @return a new List with the remaining objects. + */ + public static List toList(Iterator iterator) { + List copy = new ArrayList<>(); + while (iterator.hasNext()) { + copy.add(iterator.next()); + } + return copy; + } +} From a90fcc23916c8768087135e68d8499053b41e860 Mon Sep 17 00:00:00 2001 From: Hannes Pernpeintner Date: Wed, 2 Sep 2015 17:21:20 +0200 Subject: [PATCH 03/12] #184 Fluent interface pattern, documentation changed, collecting operations optimized --- .../fluentiterable/FluentIterable.java | 17 +++-- .../lazy/DecoratingIterator.java | 24 ++++--- .../lazy/LazyFluentIterable.java | 69 ++++++------------- .../simple/SimpleFluentIterable.java | 39 ++++------- 4 files changed, 56 insertions(+), 93 deletions(-) diff --git a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/FluentIterable.java b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/FluentIterable.java index 7bdaf274c..919cf5664 100644 --- a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/FluentIterable.java +++ b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/FluentIterable.java @@ -4,7 +4,6 @@ import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.Optional; -import java.util.function.Consumer; import java.util.function.Function; import java.util.function.Predicate; @@ -18,7 +17,7 @@ import java.util.function.Predicate; public interface FluentIterable extends Iterable { /** - * Filters the iteration with the given predicate. + * Filters the contents of Iterable using the given predicate, leaving only the ones which satisfy the predicate. * @param predicate the condition to test with for the filtering. If the test * is negative, the tested object is removed by the iterator. * @return a filtered FluentIterable @@ -26,13 +25,8 @@ public interface FluentIterable extends Iterable { FluentIterable filter(Predicate predicate); /** - * Uses the Iterable interface's forEach method to apply a given function - * for each object of the iterator. This is a terminating operation. - */ - void forEachDo(Consumer action); - - /** - * Evaluates the iteration and returns the first element. This is a terminating operation. + * Returns an Optional containing the first element of this iterable if present, + * else returns Optional.empty(). * @return the first element after the iteration is evaluated */ Optional first(); @@ -62,6 +56,11 @@ public interface FluentIterable extends Iterable { * @return a new FluentIterable of the new type */ FluentIterable map(Function function); + + /** + * Returns the contents of this Iterable as a List. + * @return a List representation of this Iterable + */ List asList(); /** diff --git a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/DecoratingIterator.java b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/DecoratingIterator.java index 0e5b410cc..35c4cc0ae 100644 --- a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/DecoratingIterator.java +++ b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/DecoratingIterator.java @@ -22,7 +22,7 @@ public abstract class DecoratingIterator implements Iterator { } /** - * Precomputes and caches the next element of the iteration. + * Precomputes and saves the next element of the Iterable. null is considered as end of data. * @return true if a next element is available */ @Override @@ -32,22 +32,24 @@ public abstract class DecoratingIterator implements Iterator { } /** - * Returns the next element of the iteration. This implementation caches it. - * If no next element is cached, it is computed. - * @return the next element obf the iteration + * Returns the next element of the Iterable. + * @return the next element of the Iterable, or null if not present. */ @Override public final TYPE next() { - TYPE result = next; - next = null; - result = (result == null ? fromIterator.next() : result); - return result; + if (next == null) { + return fromIterator.next(); + } else { + final TYPE result = next; + next = null; + return result; + } } /** - * Computes the next object of the iteration. Can be implemented to - * realize custom behaviour for an iteration process. - * @return + * Computes the next object of the Iterable. Can be implemented to + * realize custom behaviour for an iteration process. null is considered as end of data. + * @return the next element of the Iterable. */ public abstract TYPE computeNext(); } diff --git a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/LazyFluentIterable.java b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/LazyFluentIterable.java index c6db4d2cd..27bca1bf6 100644 --- a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/LazyFluentIterable.java +++ b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/LazyFluentIterable.java @@ -37,7 +37,7 @@ public class LazyFluentIterable implements FluentIterable { } /** - * Adds a filter operation to the operation chain and returns a new iterable. + * Filters the contents of Iterable using the given predicate, leaving only the ones which satisfy the predicate. * @param predicate the condition to test with for the filtering. If the test * is negative, the tested object is removed by the iterator. * @return a new FluentIterable object that decorates the source iterable @@ -50,53 +50,33 @@ public class LazyFluentIterable implements FluentIterable { return new DecoratingIterator(iterable.iterator()) { @Override public TYPE computeNext() { - while(true) { - if(fromIterator.hasNext()) { - TYPE candidate = fromIterator.next(); - if(!predicate.test(candidate)) { - continue; - } - return candidate; + while(fromIterator.hasNext()) { + TYPE candidate = fromIterator.next(); + if(!predicate.test(candidate)) { + continue; } - - return null; + return candidate; } + + return null; } }; } }; } - /** - * Uses the Iterable interface's forEach method to apply a given function - * for each object of the iterator. Is a terminating operation. - * @param action the action for each object - */ - @Override - public void forEachDo(Consumer action) { - Iterator newIterator = iterable.iterator(); - while(newIterator.hasNext()) { - action.accept(newIterator.next()); - } - } - /** * Can be used to collect objects from the iteration. Is a terminating operation. - * @return an option of the first object of the iteration + * @return an Optional containing the first object of this Iterable */ @Override public Optional first() { - Optional result = Optional.empty(); - List list = first(1).asList(); - if(!list.isEmpty()) { - result = Optional.of(list.get(0)); - } - - return result; + Iterator resultIterator = first(1).iterator(); + return resultIterator.hasNext() ? Optional.of(resultIterator.next()) : Optional.empty(); } /** - * Can be used to collect objects from the iteration. Is a terminating operation. + * Can be used to collect objects from the iteration. * @param count defines the number of objects to return * @return the same FluentIterable with a collection decimated to a maximum of 'count' first objects. */ @@ -126,21 +106,18 @@ public class LazyFluentIterable implements FluentIterable { /** * Can be used to collect objects from the iteration. Is a terminating operation. - * @return an option of the last object of the iteration + * @return an Optional containing the last object of this Iterable */ @Override public Optional last() { - Optional result = Optional.empty(); - List list = last(1).asList(); - if(!list.isEmpty()) { - result = Optional.of(list.get(0)); - } - - return result; + Iterator resultIterator = last(1).iterator(); + return resultIterator.hasNext() ? Optional.of(resultIterator.next()) : Optional.empty(); } /** - * Can be used to collect objects from the iteration. Is a terminating operation. + * Can be used to collect objects from the Iterable. Is a terminating operation. + * This operation is memory intensive, because the contents of this Iterable + * are collected into a List, when the next object is requested. * @param count defines the number of objects to return * @return the same FluentIterable with a collection decimated to a maximum of 'count' last objects */ @@ -193,13 +170,11 @@ public class LazyFluentIterable implements FluentIterable { Iterator oldTypeIterator = iterable.iterator(); @Override public NEW_TYPE computeNext() { - while(true) { - if(oldTypeIterator.hasNext()) { - TYPE candidate = oldTypeIterator.next(); - return function.apply(candidate); - } - return null; + while(oldTypeIterator.hasNext()) { + TYPE candidate = oldTypeIterator.next(); + return function.apply(candidate); } + return null; } }; } diff --git a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/simple/SimpleFluentIterable.java b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/simple/SimpleFluentIterable.java index efaa87bbb..a4bf77218 100644 --- a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/simple/SimpleFluentIterable.java +++ b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/simple/SimpleFluentIterable.java @@ -26,7 +26,7 @@ public class SimpleFluentIterable implements FluentIterable { } /** - * Iterates over all elements of this iterator and filters them. + * Filters the contents of Iterable using the given predicate, leaving only the ones which satisfy the predicate. * @param predicate the condition to test with for the filtering. If the test * is negative, the tested object is removed by the iterator. * @return the same FluentIterable with a filtered collection @@ -44,30 +44,17 @@ public class SimpleFluentIterable implements FluentIterable { } /** - * Uses the Iterable interface's forEach method to apply a given function - * for each object of the iterator. Is a terminating operation. - * @param action the action for each object - */ - @Override - public void forEachDo(Consumer action) { - iterable.forEach(action); - } - - /** - * Can be used to collect objects from the iteration. Is a terminating operation. - * @return an option of the first object of the iteration + * Can be used to collect objects from the Iterable. Is a terminating operation. + * @return an option of the first object of the Iterable */ @Override public final Optional first() { - List list = first(1).asList(); - if(list.isEmpty()) { - return Optional.empty(); - } - return Optional.of(list.get(0)); + Iterator resultIterator = first(1).iterator(); + return resultIterator.hasNext() ? Optional.of(resultIterator.next()) : Optional.empty(); } /** - * Can be used to collect objects from the iteration. Is a terminating operation. + * Can be used to collect objects from the Iterable. Is a terminating operation. * @param count defines the number of objects to return * @return the same FluentIterable with a collection decimated to a maximum of 'count' first objects. */ @@ -86,8 +73,8 @@ public class SimpleFluentIterable implements FluentIterable { } /** - * Can be used to collect objects from the iteration. Is a terminating operation. - * @return an option of the last object of the iteration + * Can be used to collect objects from the Iterable. Is a terminating operation. + * @return an option of the last object of the Iterable */ @Override public final Optional last() { @@ -99,7 +86,7 @@ public class SimpleFluentIterable implements FluentIterable { } /** - * Can be used to collect objects from the iteration. Is a terminating operation. + * Can be used to collect objects from the Iterable. Is a terminating operation. * @param count defines the number of objects to return * @return the same FluentIterable with a collection decimated to a maximum of 'count' last objects */ @@ -136,8 +123,8 @@ public class SimpleFluentIterable implements FluentIterable { } /** - * Collects all remaining objects of this iteration into a list. - * @return a list with all remaining objects of this iteration + * Collects all remaining objects of this Iterable into a list. + * @return a list with all remaining objects of this Iterable */ @Override public List asList() { @@ -168,7 +155,7 @@ public class SimpleFluentIterable implements FluentIterable { } /** - * @return the count of remaining objects in the current iteration + * @return the count of remaining objects of the current Iterable */ public final int getRemainingElementsCount() { int counter = 0; @@ -181,7 +168,7 @@ public class SimpleFluentIterable implements FluentIterable { } /** - * Collects the remaining objects of the given iterators iteration into an List. + * Collects the remaining objects of the given iterator into a List. * @return a new List with the remaining objects. */ public static List toList(Iterator iterator) { From ee47ae021aed75b1c467e31f75729224c02f943b Mon Sep 17 00:00:00 2001 From: Hannes Pernpeintner Date: Thu, 3 Sep 2015 18:49:52 +0200 Subject: [PATCH 04/12] #184 Fluent interface pattern, added cached initialization to anonymous iterator for lazy fluentiterable, small documentation changes --- .../lazy/DecoratingIterator.java | 2 +- .../lazy/LazyFluentIterable.java | 28 ++++++++++++------- .../simple/SimpleFluentIterable.java | 1 + 3 files changed, 20 insertions(+), 11 deletions(-) diff --git a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/DecoratingIterator.java b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/DecoratingIterator.java index 35c4cc0ae..3c1230bce 100644 --- a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/DecoratingIterator.java +++ b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/DecoratingIterator.java @@ -4,7 +4,7 @@ import java.util.Iterator; /** * This class is used to realize LazyFluentIterables. It decorates - * a given iterator. + * a given iterator. Does not support consecutive hasNext() calls. * @param */ public abstract class DecoratingIterator implements Iterator { diff --git a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/LazyFluentIterable.java b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/LazyFluentIterable.java index 27bca1bf6..998bbd659 100644 --- a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/LazyFluentIterable.java +++ b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/LazyFluentIterable.java @@ -126,19 +126,14 @@ public class LazyFluentIterable implements FluentIterable { @Override public Iterator iterator() { return new DecoratingIterator(iterable.iterator()) { - int currentIndex = 0; + public int stopIndex; + public int totalElementsCount; + private List list; + private int currentIndex = 0; @Override public TYPE computeNext() { - List list = new ArrayList<>(); - - Iterator newIterator = iterable.iterator(); - while(newIterator.hasNext()) { - list.add(newIterator.next()); - } - - int totalElementsCount = list.size(); - int stopIndex = totalElementsCount - count; + initialize(); TYPE candidate = null; while(currentIndex < stopIndex && fromIterator.hasNext()) { @@ -150,6 +145,19 @@ public class LazyFluentIterable implements FluentIterable { } return candidate; } + + private void initialize() { + if(list == null) { + list = new ArrayList<>(); + Iterator newIterator = iterable.iterator(); + while(newIterator.hasNext()) { + list.add(newIterator.next()); + } + + totalElementsCount = list.size(); + stopIndex = totalElementsCount - count; + } + } }; } }; diff --git a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/simple/SimpleFluentIterable.java b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/simple/SimpleFluentIterable.java index a4bf77218..0736387e5 100644 --- a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/simple/SimpleFluentIterable.java +++ b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/simple/SimpleFluentIterable.java @@ -10,6 +10,7 @@ import java.util.function.Predicate; /** * This is a simple implementation of the FluentIterable interface. It evaluates * all chained operations eagerly. + * This implementation would be costly to be utilized in real applications. * @param the type of the objects the iteration is about */ public class SimpleFluentIterable implements FluentIterable { From fb13ddc5d6ca34975c5c0bf474987e6b1c19c34a Mon Sep 17 00:00:00 2001 From: Hannes Pernpeintner Date: Mon, 7 Sep 2015 13:25:26 +0200 Subject: [PATCH 05/12] #184 Fluent interface pattern, added uml, adjusted style, added pattern description --- faq.md | 4 + fluentinterface/etc/fluentinterface.png | Bin 0 -> 59199 bytes fluentinterface/etc/fluentinterface.ucls | 100 +++++ fluentinterface/index.md | 28 ++ fluentinterface/pom.xml | 2 +- .../com/iluwatar/fluentinterface/App.java | 174 ++++---- .../fluentiterable/FluentIterable.java | 123 +++--- .../lazy/DecoratingIterator.java | 87 ++-- .../lazy/LazyFluentIterable.java | 400 +++++++++--------- .../simple/SimpleFluentIterable.java | 334 ++++++++------- .../com/iluwatar/fluentinterface/AppTest.java | 10 +- 11 files changed, 727 insertions(+), 535 deletions(-) create mode 100644 fluentinterface/etc/fluentinterface.png create mode 100644 fluentinterface/etc/fluentinterface.ucls create mode 100644 fluentinterface/index.md diff --git a/faq.md b/faq.md index 5633a693d..b98bc7589 100644 --- a/faq.md +++ b/faq.md @@ -61,3 +61,7 @@ As for performance and scalability, pools can become bottlenecks, if all the pooled objects are in use and more clients need them, threads will become blocked waiting for available object from the pool. This is not the case with Flyweight. + +### Q7: What are the differences between FluentInterface and Builder patterns? {#Q7} + +Fluent interfaces are sometimes confused with the Builder pattern, because they share method chaining and a fluent usage. However, fluent interfaces are not primarily used to create shared (mutable) objects, but to configure complex objects without having to respecify the target object on every property change. \ No newline at end of file diff --git a/fluentinterface/etc/fluentinterface.png b/fluentinterface/etc/fluentinterface.png new file mode 100644 index 0000000000000000000000000000000000000000..4a79ce0b7f69395cb81822042ae9c85f90da5e17 GIT binary patch literal 59199 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 literal 0 HcmV?d00001 diff --git a/fluentinterface/etc/fluentinterface.ucls b/fluentinterface/etc/fluentinterface.ucls new file mode 100644 index 000000000..3277148cd --- /dev/null +++ b/fluentinterface/etc/fluentinterface.ucls @@ -0,0 +1,100 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/fluentinterface/index.md b/fluentinterface/index.md new file mode 100644 index 000000000..942867933 --- /dev/null +++ b/fluentinterface/index.md @@ -0,0 +1,28 @@ +--- +layout: pattern +title: Fluent Interface +folder: fluentinterface +permalink: /patterns/fluentinterface/ +categories: Architectural +tags: Java +--- + +**Intent:** A fluent interface provides an easy-readable, flowing interface, that often mimics a domain specific language. Using this pattern results in code that can be read nearly as human language. + +![Fluent Interface](./etc/fluentinterface.png "Fluent Interface") + +**Applicability:** Use the Fluent Interface pattern when + +* you provide an API that would benefit from a DSL-like usage +* you have objects that are difficult to configure or use + +**Real world examples:** + +* [Java 8 Stream API](http://www.oracle.com/technetwork/articles/java/ma14-java-se-8-streams-2177646.html) +* [Google Guava FluentInterable](https://github.com/google/guava/wiki/FunctionalExplained) +* [JOOQ](http://www.jooq.org/doc/3.0/manual/getting-started/use-cases/jooq-as-a-standalone-sql-builder/) + +**Credits** + +* [Fluent Interface - Martin Fowler](http://www.martinfowler.com/bliki/FluentInterface.html) +* [Evolutionary architecture and emergent design: Fluent interfaces - Neal Ford](http://www.ibm.com/developerworks/library/j-eaed14/) \ No newline at end of file diff --git a/fluentinterface/pom.xml b/fluentinterface/pom.xml index c78c182e3..be8ab8039 100644 --- a/fluentinterface/pom.xml +++ b/fluentinterface/pom.xml @@ -5,7 +5,7 @@ java-design-patterns com.iluwatar - 1.5.0 + 1.6.0 4.0.0 diff --git a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/App.java b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/App.java index 96a2db323..b9e5909f1 100644 --- a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/App.java +++ b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/App.java @@ -1,5 +1,6 @@ package com.iluwatar.fluentinterface; +import com.iluwatar.fluentinterface.fluentiterable.FluentIterable; import com.iluwatar.fluentinterface.fluentiterable.lazy.LazyFluentIterable; import com.iluwatar.fluentinterface.fluentiterable.simple.SimpleFluentIterable; @@ -9,96 +10,113 @@ import java.util.function.Predicate; import static java.lang.String.valueOf; +/** + * Fluent interface pattern is useful when you want to provide an easy readable, flowing API. Those + * interfaces tend to mimic domain specific languages, so they can nearly be read as human + * languages. + *

+ * In this example two implementations of a {@link FluentIterable} interface are given. The + * SimpleFluentIterable evaluates eagerly and would be too costly for real world applications. The + * LazyFluentIterable is evaluated on termination. Their usage is demonstrated with a simple number + * list that is filtered, transformed and collected. The result is printed afterwards. + *

+ */ public class App { - public static void main(String[] args) { + public static void main(String[] args) { - List integerList = new ArrayList() {{ - add(1); - add(-61); - add(14); - add(-22); - add(18); - add(-87); - add(6); - add(64); - add(-82); - add(26); - add(-98); - add(97); - add(45); - add(23); - add(2); - add(-68); - add(45); - }}; - prettyPrint("The initial list contains: ", integerList); + List integerList = new ArrayList() { + { + add(1); + add(-61); + add(14); + add(-22); + add(18); + add(-87); + add(6); + add(64); + add(-82); + add(26); + add(-98); + add(97); + add(45); + add(23); + add(2); + add(-68); + add(45); + } + }; + prettyPrint("The initial list contains: ", integerList); - List firstFiveNegatives = SimpleFluentIterable.from(integerList) - .filter(negatives()) - .first(3) - .asList(); - prettyPrint("The first three negative values are: ", firstFiveNegatives); + List firstFiveNegatives = + SimpleFluentIterable.fromCopyOf(integerList).filter(negatives()).first(3).asList(); + prettyPrint("The first three negative values are: ", firstFiveNegatives); - List lastTwoPositives = SimpleFluentIterable.from(integerList) - .filter(positives()) - .last(2) - .asList(); - prettyPrint("The last two positive values are: ", lastTwoPositives); + List lastTwoPositives = + SimpleFluentIterable.fromCopyOf(integerList).filter(positives()).last(2).asList(); + prettyPrint("The last two positive values are: ", lastTwoPositives); - SimpleFluentIterable.from(integerList) - .filter(number -> number%2 == 0) - .first() - .ifPresent(evenNumber -> System.out.println(String.format("The first even number is: %d", evenNumber))); + SimpleFluentIterable + .fromCopyOf(integerList) + .filter(number -> number % 2 == 0) + .first() + .ifPresent( + evenNumber -> System.out.println(String.format("The first even number is: %d", + evenNumber))); - List transformedList = SimpleFluentIterable.from(integerList) - .filter(negatives()) - .map(transformToString()) - .asList(); - prettyPrint("A string-mapped list of negative numbers contains: ", transformedList); + List transformedList = + SimpleFluentIterable.fromCopyOf(integerList).filter(negatives()).map(transformToString()) + .asList(); + prettyPrint("A string-mapped list of negative numbers contains: ", transformedList); - List lastTwoOfFirstFourStringMapped = LazyFluentIterable.from(integerList) - .filter(positives()) - .first(4) - .last(2) - .map(number -> "String[" + String.valueOf(number) + "]") - .asList(); - prettyPrint("The lazy list contains the last two of the first four positive numbers mapped to Strings: ", lastTwoOfFirstFourStringMapped); + List lastTwoOfFirstFourStringMapped = + LazyFluentIterable.from(integerList).filter(positives()).first(4).last(2) + .map(number -> "String[" + String.valueOf(number) + "]").asList(); + prettyPrint( + "The lazy list contains the last two of the first four positive numbers mapped to Strings: ", + lastTwoOfFirstFourStringMapped); - LazyFluentIterable.from(integerList) - .filter(negatives()) - .first(2) - .last() - .ifPresent(lastOfFirstTwo -> System.out.println(String.format("The last of the first two negatives is: %d", lastOfFirstTwo))); + LazyFluentIterable + .from(integerList) + .filter(negatives()) + .first(2) + .last() + .ifPresent( + lastOfFirstTwo -> System.out.println(String.format( + "The last of the first two negatives is: %d", lastOfFirstTwo))); + } + + private static Function transformToString() { + return integer -> "String[" + valueOf(integer) + "]"; + } + + private static Predicate negatives() { + return integer -> (integer < 0); + } + + private static Predicate positives() { + return integer -> (integer > 0); + } + + private static void prettyPrint(String prefix, Iterable iterable) { + prettyPrint(", ", prefix, ".", iterable); + } + + private static void prettyPrint(String prefix, String suffix, Iterable iterable) { + prettyPrint(", ", prefix, suffix, iterable); + } + + private static void prettyPrint(String delimiter, String prefix, String suffix, + Iterable iterable) { + StringJoiner joiner = new StringJoiner(delimiter, prefix, "."); + Iterator iterator = iterable.iterator(); + while (iterator.hasNext()) { + joiner.add(iterator.next().toString()); } - private static Function transformToString() { - return integer -> "String[" + valueOf(integer) + "]"; - } - private static Predicate negatives() { - return integer -> (integer < 0); - } - private static Predicate positives() { - return integer -> (integer > 0); - } - - private static void prettyPrint(String prefix, Iterable iterable) { - prettyPrint(", ", prefix, ".", iterable); - } - private static void prettyPrint(String prefix, String suffix, Iterable iterable) { - prettyPrint(", ", prefix, suffix, iterable); - } - - private static void prettyPrint(String delimiter, String prefix, String suffix, Iterable iterable) { - StringJoiner joiner = new StringJoiner(delimiter, prefix, "."); - Iterator iterator = iterable.iterator(); - while (iterator.hasNext()) { - joiner.add(iterator.next().toString()); - } - - System.out.println(joiner); - } + System.out.println(joiner); + } } diff --git a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/FluentIterable.java b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/FluentIterable.java index 919cf5664..5c4df0391 100644 --- a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/FluentIterable.java +++ b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/FluentIterable.java @@ -8,73 +8,82 @@ import java.util.function.Function; import java.util.function.Predicate; /** - * The FluentIterable is a more convenient implementation of the common iterable interface based - * on the fluent interface design pattern. - * This interface defines common operations, but - * doesn't aim to be complete. It was inspired by Guava's com.google.common.collect.FluentIterable. + * The FluentIterable is a more convenient implementation of the common iterable interface based on + * the fluent interface design pattern. This interface defines common operations, but doesn't aim to + * be complete. It was inspired by Guava's com.google.common.collect.FluentIterable. + * * @param is the class of objects the iterable contains */ public interface FluentIterable extends Iterable { - /** - * Filters the contents of Iterable using the given predicate, leaving only the ones which satisfy the predicate. - * @param predicate the condition to test with for the filtering. If the test - * is negative, the tested object is removed by the iterator. - * @return a filtered FluentIterable - */ - FluentIterable filter(Predicate predicate); + /** + * Filters the contents of Iterable using the given predicate, leaving only the ones which satisfy + * the predicate. + * + * @param predicate the condition to test with for the filtering. If the test is negative, the + * tested object is removed by the iterator. + * @return a filtered FluentIterable + */ + FluentIterable filter(Predicate predicate); - /** - * Returns an Optional containing the first element of this iterable if present, - * else returns Optional.empty(). - * @return the first element after the iteration is evaluated - */ - Optional first(); + /** + * Returns an Optional containing the first element of this iterable if present, else returns + * Optional.empty(). + * + * @return the first element after the iteration is evaluated + */ + Optional first(); - /** - * Evaluates the iteration and leaves only the count first elements. - * @return the first count elements as an Iterable - */ - FluentIterable first(int count); + /** + * Evaluates the iteration and leaves only the count first elements. + * + * @return the first count elements as an Iterable + */ + FluentIterable first(int count); - /** - * Evaluates the iteration and returns the last element. This is a terminating operation. - * @return the last element after the iteration is evaluated - */ - Optional last(); + /** + * Evaluates the iteration and returns the last element. This is a terminating operation. + * + * @return the last element after the iteration is evaluated + */ + Optional last(); - /** - * Evaluates the iteration and leaves only the count last elements. - * @return the last counts elements as an Iterable - */ - FluentIterable last(int count); + /** + * Evaluates the iteration and leaves only the count last elements. + * + * @return the last counts elements as an Iterable + */ + FluentIterable last(int count); - /** - * Transforms this FluentIterable into a new one containing objects of the type NEW_TYPE. - * @param function a function that transforms an instance of TYPE into an instance of NEW_TYPE - * @param the target type of the transformation - * @return a new FluentIterable of the new type - */ - FluentIterable map(Function function); + /** + * Transforms this FluentIterable into a new one containing objects of the type NEW_TYPE. + * + * @param function a function that transforms an instance of TYPE into an instance of NEW_TYPE + * @param the target type of the transformation + * @return a new FluentIterable of the new type + */ + FluentIterable map(Function function); - /** - * Returns the contents of this Iterable as a List. - * @return a List representation of this Iterable - */ - List asList(); + /** + * Returns the contents of this Iterable as a List. + * + * @return a List representation of this Iterable + */ + List asList(); - /** - * Utility method that iterates over iterable and adds the contents to a list. - * @param iterable the iterable to collect - * @param the type of the objects to iterate - * @return a list with all objects of the given iterator - */ - static List copyToList(Iterable iterable) { - ArrayList copy = new ArrayList<>(); - Iterator iterator = iterable.iterator(); - while (iterator.hasNext()) { - copy.add(iterator.next()); - } - return copy; + /** + * Utility method that iterates over iterable and adds the contents to a list. + * + * @param iterable the iterable to collect + * @param the type of the objects to iterate + * @return a list with all objects of the given iterator + */ + static List copyToList(Iterable iterable) { + ArrayList copy = new ArrayList<>(); + Iterator iterator = iterable.iterator(); + while (iterator.hasNext()) { + copy.add(iterator.next()); } + return copy; + } } diff --git a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/DecoratingIterator.java b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/DecoratingIterator.java index 3c1230bce..e80356d8e 100644 --- a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/DecoratingIterator.java +++ b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/DecoratingIterator.java @@ -3,53 +3,58 @@ package com.iluwatar.fluentinterface.fluentiterable.lazy; import java.util.Iterator; /** - * This class is used to realize LazyFluentIterables. It decorates - * a given iterator. Does not support consecutive hasNext() calls. + * This class is used to realize LazyFluentIterables. It decorates a given iterator. Does not + * support consecutive hasNext() calls. + * * @param */ public abstract class DecoratingIterator implements Iterator { - protected final Iterator fromIterator; + protected final Iterator fromIterator; - private TYPE next = null; + private TYPE next = null; - /** - * Creates an iterator that decorates the given iterator. - * @param fromIterator - */ - public DecoratingIterator(Iterator fromIterator) { - this.fromIterator = fromIterator; + /** + * Creates an iterator that decorates the given iterator. + * + * @param fromIterator + */ + public DecoratingIterator(Iterator fromIterator) { + this.fromIterator = fromIterator; + } + + /** + * Precomputes and saves the next element of the Iterable. null is considered as end of data. + * + * @return true if a next element is available + */ + @Override + public final boolean hasNext() { + next = computeNext(); + return next != null; + } + + /** + * Returns the next element of the Iterable. + * + * @return the next element of the Iterable, or null if not present. + */ + @Override + public final TYPE next() { + if (next == null) { + return fromIterator.next(); + } else { + final TYPE result = next; + next = null; + return result; } + } - /** - * Precomputes and saves the next element of the Iterable. null is considered as end of data. - * @return true if a next element is available - */ - @Override - public final boolean hasNext() { - next = computeNext(); - return next != null; - } - - /** - * Returns the next element of the Iterable. - * @return the next element of the Iterable, or null if not present. - */ - @Override - public final TYPE next() { - if (next == null) { - return fromIterator.next(); - } else { - final TYPE result = next; - next = null; - return result; - } - } - - /** - * Computes the next object of the Iterable. Can be implemented to - * realize custom behaviour for an iteration process. null is considered as end of data. - * @return the next element of the Iterable. - */ - public abstract TYPE computeNext(); + /** + * Computes the next object of the Iterable. Can be implemented to realize custom behaviour for an + * iteration process. null is considered as end of data. + * + * @return the next element of the Iterable. + */ + public abstract TYPE computeNext(); } diff --git a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/LazyFluentIterable.java b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/LazyFluentIterable.java index 998bbd659..5adfa83ce 100644 --- a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/LazyFluentIterable.java +++ b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/LazyFluentIterable.java @@ -11,209 +11,221 @@ import java.util.function.Function; import java.util.function.Predicate; /** - * This is a lazy implementation of the FluentIterable interface. It evaluates - * all chained operations when a terminating operation is applied. + * This is a lazy implementation of the FluentIterable interface. It evaluates all chained + * operations when a terminating operation is applied. + * * @param the type of the objects the iteration is about */ public class LazyFluentIterable implements FluentIterable { - private final Iterable iterable; + private final Iterable iterable; - /** - * This constructor creates a new LazyFluentIterable. It wraps the - * given iterable. - * @param iterable the iterable this FluentIterable works on. - */ - protected LazyFluentIterable(Iterable iterable) { - this.iterable = iterable; - } + /** + * This constructor creates a new LazyFluentIterable. It wraps the given iterable. + * + * @param iterable the iterable this FluentIterable works on. + */ + protected LazyFluentIterable(Iterable iterable) { + this.iterable = iterable; + } - /** - * This constructor can be used to implement anonymous subclasses - * of the LazyFluentIterable. - */ - protected LazyFluentIterable() { - iterable = this; - } + /** + * This constructor can be used to implement anonymous subclasses of the LazyFluentIterable. + */ + protected LazyFluentIterable() { + iterable = this; + } - /** - * Filters the contents of Iterable using the given predicate, leaving only the ones which satisfy the predicate. - * @param predicate the condition to test with for the filtering. If the test - * is negative, the tested object is removed by the iterator. - * @return a new FluentIterable object that decorates the source iterable - */ - @Override - public FluentIterable filter(Predicate predicate) { - return new LazyFluentIterable() { - @Override - public Iterator iterator() { - return new DecoratingIterator(iterable.iterator()) { - @Override - public TYPE computeNext() { - while(fromIterator.hasNext()) { - TYPE candidate = fromIterator.next(); - if(!predicate.test(candidate)) { - continue; - } - return candidate; - } - - return null; - } - }; - } - }; - } - - /** - * Can be used to collect objects from the iteration. Is a terminating operation. - * @return an Optional containing the first object of this Iterable - */ - @Override - public Optional first() { - Iterator resultIterator = first(1).iterator(); - return resultIterator.hasNext() ? Optional.of(resultIterator.next()) : Optional.empty(); - } - - /** - * Can be used to collect objects from the iteration. - * @param count defines the number of objects to return - * @return the same FluentIterable with a collection decimated to a maximum of 'count' first objects. - */ - @Override - public FluentIterable first(int count) { - return new LazyFluentIterable() { - @Override - public Iterator iterator() { - return new DecoratingIterator(iterable.iterator()) { - int currentIndex = 0; - - @Override - public TYPE computeNext() { - if(currentIndex < count) { - if(fromIterator.hasNext()) { - TYPE candidate = fromIterator.next(); - currentIndex++; - return candidate; - } - } - return null; - } - }; - } - }; - } - - /** - * Can be used to collect objects from the iteration. Is a terminating operation. - * @return an Optional containing the last object of this Iterable - */ - @Override - public Optional last() { - Iterator resultIterator = last(1).iterator(); - return resultIterator.hasNext() ? Optional.of(resultIterator.next()) : Optional.empty(); - } - - /** - * Can be used to collect objects from the Iterable. Is a terminating operation. - * This operation is memory intensive, because the contents of this Iterable - * are collected into a List, when the next object is requested. - * @param count defines the number of objects to return - * @return the same FluentIterable with a collection decimated to a maximum of 'count' last objects - */ - @Override - public FluentIterable last(int count) {return new LazyFluentIterable() { - @Override - public Iterator iterator() { - return new DecoratingIterator(iterable.iterator()) { - public int stopIndex; - public int totalElementsCount; - private List list; - private int currentIndex = 0; - - @Override - public TYPE computeNext() { - initialize(); - - TYPE candidate = null; - while(currentIndex < stopIndex && fromIterator.hasNext()) { - currentIndex++; - fromIterator.next(); - } - if(currentIndex >= stopIndex && fromIterator.hasNext()) { - candidate = fromIterator.next(); - } - return candidate; - } - - private void initialize() { - if(list == null) { - list = new ArrayList<>(); - Iterator newIterator = iterable.iterator(); - while(newIterator.hasNext()) { - list.add(newIterator.next()); - } - - totalElementsCount = list.size(); - stopIndex = totalElementsCount - count; - } - } - }; - } - }; - } - - /** - * Transforms this FluentIterable into a new one containing objects of the type NEW_TYPE. - * @param function a function that transforms an instance of TYPE into an instance of NEW_TYPE - * @param the target type of the transformation - * @return a new FluentIterable of the new type - */ - @Override - public FluentIterable map(Function function) { - return new LazyFluentIterable() { - @Override - public Iterator iterator() { - return new DecoratingIterator(null) { - Iterator oldTypeIterator = iterable.iterator(); - @Override - public NEW_TYPE computeNext() { - while(oldTypeIterator.hasNext()) { - TYPE candidate = oldTypeIterator.next(); - return function.apply(candidate); - } - return null; - } - }; - } - }; - } - - /** - * Collects all remaining objects of this iteration into a list. - * @return a list with all remaining objects of this iteration - */ - @Override - public List asList() { - List copy = FluentIterable.copyToList(iterable); - return copy; - } - - @Override - public Iterator iterator() { + /** + * Filters the contents of Iterable using the given predicate, leaving only the ones which satisfy + * the predicate. + * + * @param predicate the condition to test with for the filtering. If the test is negative, the + * tested object is removed by the iterator. + * @return a new FluentIterable object that decorates the source iterable + */ + @Override + public FluentIterable filter(Predicate predicate) { + return new LazyFluentIterable() { + @Override + public Iterator iterator() { return new DecoratingIterator(iterable.iterator()) { - @Override - public TYPE computeNext() { - return fromIterator.next(); + @Override + public TYPE computeNext() { + while (fromIterator.hasNext()) { + TYPE candidate = fromIterator.next(); + if (!predicate.test(candidate)) { + continue; + } + return candidate; } - }; - } - /** - * @return a FluentIterable from a given iterable. Calls the LazyFluentIterable constructor. - */ - public static final FluentIterable from(Iterable iterable) { - return new LazyFluentIterable<>(iterable); - } + return null; + } + }; + } + }; + } + + /** + * Can be used to collect objects from the iteration. Is a terminating operation. + * + * @return an Optional containing the first object of this Iterable + */ + @Override + public Optional first() { + Iterator resultIterator = first(1).iterator(); + return resultIterator.hasNext() ? Optional.of(resultIterator.next()) : Optional.empty(); + } + + /** + * Can be used to collect objects from the iteration. + * + * @param count defines the number of objects to return + * @return the same FluentIterable with a collection decimated to a maximum of 'count' first + * objects. + */ + @Override + public FluentIterable first(int count) { + return new LazyFluentIterable() { + @Override + public Iterator iterator() { + return new DecoratingIterator(iterable.iterator()) { + int currentIndex = 0; + + @Override + public TYPE computeNext() { + if (currentIndex < count) { + if (fromIterator.hasNext()) { + TYPE candidate = fromIterator.next(); + currentIndex++; + return candidate; + } + } + return null; + } + }; + } + }; + } + + /** + * Can be used to collect objects from the iteration. Is a terminating operation. + * + * @return an Optional containing the last object of this Iterable + */ + @Override + public Optional last() { + Iterator resultIterator = last(1).iterator(); + return resultIterator.hasNext() ? Optional.of(resultIterator.next()) : Optional.empty(); + } + + /** + * Can be used to collect objects from the Iterable. Is a terminating operation. This operation is + * memory intensive, because the contents of this Iterable are collected into a List, when the + * next object is requested. + * + * @param count defines the number of objects to return + * @return the same FluentIterable with a collection decimated to a maximum of 'count' last + * objects + */ + @Override + public FluentIterable last(int count) { + return new LazyFluentIterable() { + @Override + public Iterator iterator() { + return new DecoratingIterator(iterable.iterator()) { + private int stopIndex; + private int totalElementsCount; + private List list; + private int currentIndex = 0; + + @Override + public TYPE computeNext() { + initialize(); + + TYPE candidate = null; + while (currentIndex < stopIndex && fromIterator.hasNext()) { + currentIndex++; + fromIterator.next(); + } + if (currentIndex >= stopIndex && fromIterator.hasNext()) { + candidate = fromIterator.next(); + } + return candidate; + } + + private void initialize() { + if (list == null) { + list = new ArrayList<>(); + Iterator newIterator = iterable.iterator(); + while (newIterator.hasNext()) { + list.add(newIterator.next()); + } + + totalElementsCount = list.size(); + stopIndex = totalElementsCount - count; + } + } + }; + } + }; + } + + /** + * Transforms this FluentIterable into a new one containing objects of the type NEW_TYPE. + * + * @param function a function that transforms an instance of TYPE into an instance of NEW_TYPE + * @param the target type of the transformation + * @return a new FluentIterable of the new type + */ + @Override + public FluentIterable map(Function function) { + return new LazyFluentIterable() { + @Override + public Iterator iterator() { + return new DecoratingIterator(null) { + Iterator oldTypeIterator = iterable.iterator(); + + @Override + public NEW_TYPE computeNext() { + while (oldTypeIterator.hasNext()) { + TYPE candidate = oldTypeIterator.next(); + return function.apply(candidate); + } + return null; + } + }; + } + }; + } + + /** + * Collects all remaining objects of this iteration into a list. + * + * @return a list with all remaining objects of this iteration + */ + @Override + public List asList() { + List copy = FluentIterable.copyToList(iterable); + return copy; + } + + @Override + public Iterator iterator() { + return new DecoratingIterator(iterable.iterator()) { + @Override + public TYPE computeNext() { + return fromIterator.next(); + } + }; + } + + /** + * @return a FluentIterable from a given iterable. Calls the LazyFluentIterable constructor. + */ + public static final FluentIterable from(Iterable iterable) { + return new LazyFluentIterable<>(iterable); + } } diff --git a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/simple/SimpleFluentIterable.java b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/simple/SimpleFluentIterable.java index 0736387e5..db7a31954 100644 --- a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/simple/SimpleFluentIterable.java +++ b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/simple/SimpleFluentIterable.java @@ -8,175 +8,191 @@ import java.util.function.Function; import java.util.function.Predicate; /** - * This is a simple implementation of the FluentIterable interface. It evaluates - * all chained operations eagerly. - * This implementation would be costly to be utilized in real applications. + * This is a simple implementation of the FluentIterable interface. It evaluates all chained + * operations eagerly. This implementation would be costly to be utilized in real applications. + * * @param the type of the objects the iteration is about */ public class SimpleFluentIterable implements FluentIterable { - private final Iterable iterable; + private final Iterable iterable; - /** - * This constructor creates a copy of a given iterable's contents. - * @param iterable the iterable this interface copies to work on. - */ - protected SimpleFluentIterable(Iterable iterable) { - List copy = FluentIterable.copyToList(iterable); - this.iterable = copy; + /** + * This constructor creates a copy of a given iterable's contents. + * + * @param iterable the iterable this interface copies to work on. + */ + protected SimpleFluentIterable(Iterable iterable) { + this.iterable = iterable; + } + + /** + * Filters the contents of Iterable using the given predicate, leaving only the ones which satisfy + * the predicate. + * + * @param predicate the condition to test with for the filtering. If the test is negative, the + * tested object is removed by the iterator. + * @return the same FluentIterable with a filtered collection + */ + @Override + public final FluentIterable filter(Predicate predicate) { + Iterator iterator = iterator(); + while (iterator.hasNext()) { + TYPE nextElement = iterator.next(); + if (!predicate.test(nextElement)) { + iterator.remove(); + } + } + return this; + } + + /** + * Can be used to collect objects from the Iterable. Is a terminating operation. + * + * @return an option of the first object of the Iterable + */ + @Override + public final Optional first() { + Iterator resultIterator = first(1).iterator(); + return resultIterator.hasNext() ? Optional.of(resultIterator.next()) : Optional.empty(); + } + + /** + * Can be used to collect objects from the Iterable. Is a terminating operation. + * + * @param count defines the number of objects to return + * @return the same FluentIterable with a collection decimated to a maximum of 'count' first + * objects. + */ + @Override + public final FluentIterable first(int count) { + Iterator iterator = iterator(); + int currentCount = 0; + while (iterator.hasNext()) { + iterator.next(); + if (currentCount >= count) { + iterator.remove(); + } + currentCount++; + } + return this; + } + + /** + * Can be used to collect objects from the Iterable. Is a terminating operation. + * + * @return an option of the last object of the Iterable + */ + @Override + public final Optional last() { + List list = last(1).asList(); + if (list.isEmpty()) { + return Optional.empty(); + } + return Optional.of(list.get(0)); + } + + /** + * Can be used to collect objects from the Iterable. Is a terminating operation. + * + * @param count defines the number of objects to return + * @return the same FluentIterable with a collection decimated to a maximum of 'count' last + * objects + */ + @Override + public final FluentIterable last(int count) { + int remainingElementsCount = getRemainingElementsCount(); + Iterator iterator = iterator(); + int currentIndex = 0; + while (iterator.hasNext()) { + iterator.next(); + if (currentIndex < remainingElementsCount - count) { + iterator.remove(); + } + currentIndex++; } - /** - * Filters the contents of Iterable using the given predicate, leaving only the ones which satisfy the predicate. - * @param predicate the condition to test with for the filtering. If the test - * is negative, the tested object is removed by the iterator. - * @return the same FluentIterable with a filtered collection - */ - @Override - public final FluentIterable filter(Predicate predicate) { - Iterator iterator = iterator(); - while (iterator.hasNext()) { - TYPE nextElement = iterator.next(); - if(!predicate.test(nextElement)) { - iterator.remove(); - } - } - return this; + return this; + } + + /** + * Transforms this FluentIterable into a new one containing objects of the type NEW_TYPE. + * + * @param function a function that transforms an instance of TYPE into an instance of NEW_TYPE + * @param the target type of the transformation + * @return a new FluentIterable of the new type + */ + @Override + public final FluentIterable map(Function function) { + List temporaryList = new ArrayList(); + Iterator iterator = iterator(); + while (iterator.hasNext()) { + temporaryList.add(function.apply(iterator.next())); } + return from(temporaryList); + } - /** - * Can be used to collect objects from the Iterable. Is a terminating operation. - * @return an option of the first object of the Iterable - */ - @Override - public final Optional first() { - Iterator resultIterator = first(1).iterator(); - return resultIterator.hasNext() ? Optional.of(resultIterator.next()) : Optional.empty(); + /** + * Collects all remaining objects of this Iterable into a list. + * + * @return a list with all remaining objects of this Iterable + */ + @Override + public List asList() { + return toList(iterable.iterator()); + } + + /** + * @return a FluentIterable from a given iterable. Calls the SimpleFluentIterable constructor. + */ + public static final FluentIterable from(Iterable iterable) { + return new SimpleFluentIterable<>(iterable); + } + + public static final FluentIterable fromCopyOf(Iterable iterable) { + List copy = FluentIterable.copyToList(iterable); + return new SimpleFluentIterable<>(copy); + } + + @Override + public Iterator iterator() { + return iterable.iterator(); + } + + @Override + public void forEach(Consumer action) { + iterable.forEach(action); + } + + + @Override + public Spliterator spliterator() { + return iterable.spliterator(); + } + + /** + * @return the count of remaining objects of the current Iterable + */ + public final int getRemainingElementsCount() { + int counter = 0; + Iterator iterator = iterator(); + while (iterator.hasNext()) { + iterator.next(); + counter++; } + return counter; + } - /** - * Can be used to collect objects from the Iterable. Is a terminating operation. - * @param count defines the number of objects to return - * @return the same FluentIterable with a collection decimated to a maximum of 'count' first objects. - */ - @Override - public final FluentIterable first(int count) { - Iterator iterator = iterator(); - int currentCount = 0; - while (iterator.hasNext()) { - iterator.next(); - if(currentCount >= count) { - iterator.remove(); - } - currentCount++; - } - return this; - } - - /** - * Can be used to collect objects from the Iterable. Is a terminating operation. - * @return an option of the last object of the Iterable - */ - @Override - public final Optional last() { - List list = last(1).asList(); - if(list.isEmpty()) { - return Optional.empty(); - } - return Optional.of(list.get(0)); - } - - /** - * Can be used to collect objects from the Iterable. Is a terminating operation. - * @param count defines the number of objects to return - * @return the same FluentIterable with a collection decimated to a maximum of 'count' last objects - */ - @Override - public final FluentIterable last(int count) { - int remainingElementsCount = getRemainingElementsCount(); - Iterator iterator = iterator(); - int currentIndex = 0; - while (iterator.hasNext()) { - iterator.next(); - if(currentIndex < remainingElementsCount - count) { - iterator.remove(); - } - currentIndex++; - } - - return this; - } - - /** - * Transforms this FluentIterable into a new one containing objects of the type NEW_TYPE. - * @param function a function that transforms an instance of TYPE into an instance of NEW_TYPE - * @param the target type of the transformation - * @return a new FluentIterable of the new type - */ - @Override - public final FluentIterable map(Function function) { - List temporaryList = new ArrayList(); - Iterator iterator = iterator(); - while (iterator.hasNext()) { - temporaryList.add(function.apply(iterator.next())); - } - return from(temporaryList); - } - - /** - * Collects all remaining objects of this Iterable into a list. - * @return a list with all remaining objects of this Iterable - */ - @Override - public List asList() { - return toList(iterable.iterator()); - } - - /** - * @return a FluentIterable from a given iterable. Calls the SimpleFluentIterable constructor. - */ - public static final FluentIterable from(Iterable iterable) { - return new SimpleFluentIterable<>(iterable); - } - - @Override - public Iterator iterator() { - return iterable.iterator(); - } - - @Override - public void forEach(Consumer action) { - iterable.forEach(action); - } - - - @Override - public Spliterator spliterator() { - return iterable.spliterator(); - } - - /** - * @return the count of remaining objects of the current Iterable - */ - public final int getRemainingElementsCount() { - int counter = 0; - Iterator iterator = iterator(); - while(iterator.hasNext()) { - iterator.next(); - counter++; - } - return counter; - } - - /** - * Collects the remaining objects of the given iterator into a List. - * @return a new List with the remaining objects. - */ - public static List toList(Iterator iterator) { - List copy = new ArrayList<>(); - while (iterator.hasNext()) { - copy.add(iterator.next()); - } - return copy; + /** + * Collects the remaining objects of the given iterator into a List. + * + * @return a new List with the remaining objects. + */ + public static List toList(Iterator iterator) { + List copy = new ArrayList<>(); + while (iterator.hasNext()) { + copy.add(iterator.next()); } + return copy; + } } diff --git a/fluentinterface/src/test/java/com/iluwatar/fluentinterface/AppTest.java b/fluentinterface/src/test/java/com/iluwatar/fluentinterface/AppTest.java index 32bbca430..d0abb7bf1 100644 --- a/fluentinterface/src/test/java/com/iluwatar/fluentinterface/AppTest.java +++ b/fluentinterface/src/test/java/com/iluwatar/fluentinterface/AppTest.java @@ -4,9 +4,9 @@ import org.junit.Test; public class AppTest { - @Test - public void test() { - String[] args = {}; - App.main(args); - } + @Test + public void test() { + String[] args = {}; + App.main(args); + } } From efa7e01223e21a3d126906e8020e2f0be8dec6c1 Mon Sep 17 00:00:00 2001 From: Narendra Pathai Date: Thu, 10 Sep 2015 13:12:36 +0530 Subject: [PATCH 06/12] #184 polished a few rough edges, class diagram change, and removed warnings --- fluentinterface/etc/fluentinterface.png | Bin 59199 -> 83424 bytes fluentinterface/etc/fluentinterface.ucls | 198 +++++++++--------- .../com/iluwatar/fluentinterface/App.java | 31 +-- .../lazy/LazyFluentIterable.java | 5 +- .../simple/SimpleFluentIterable.java | 2 +- 5 files changed, 108 insertions(+), 128 deletions(-) diff --git a/fluentinterface/etc/fluentinterface.png b/fluentinterface/etc/fluentinterface.png index 4a79ce0b7f69395cb81822042ae9c85f90da5e17..611fec7c6e7daa4aab70f1d61c621822333eb7b5 100644 GIT binary patch literal 83424 zcmeFZby$>L+b=wJg9uo3*8nOdAdC_cL-&wMNC^lMl7ph8Gz>@z4ALM&w@MBv-5}lF z{jCA-N1x|?-+kSM(-&{*%-aOz2R}6 z8JW#fJPVVk3*R+VXN1hXdk2poc~`V_#rTR!fqCLVZX}}M!Gi*;$RpJlz9Zuox3LJk zGfP`@Yoi-cQ;(*i44ZpiHuud@}g&-q@)!{*(WeyZ!`q@_$fQ=qbo_~VeXJmNIuE6vpu2xQk4N+5RjfA>eZaQze;)8V8TW_~OE za8~{z`!%&}UHpkW+k@SionDE@uCi|DZLDEbe1CnyFLjLdLSLM)$4!ltPXdnNWBN=C zhFP((VH-_L1K8b(umfV|kdlgoSiVr(ksr2mTx~>@=2^z|Tbii})1;v%kQkB!*?5;lzKCjM+=qq}y zUF#>kx4CegsH4zS6`B3neDE|mazF5SrI7wYm6x;r+Ed?0Xi6V`+s3($6#KCna*cf2 zry^%V*|acPB~K>@13um+V2)l{u^i4f^V@NeiIFlMDm8!eMkAwO^4~5~_k!xVt;g?tV=(6Emyz@lWW-W zLozhxaHE?>VRJQg2g@*r$x*DZ-=Agn9&`K}hJdNWATmc7Uq%DSXUX$TP9q3a23JalaaZ zwq<>8ZZt>tnLD50pC-cB%!_ttC{|Y{JEF$CEWU!TM6+ zVVk0&9~g7$)4ot%__MI&mJMb$7t)&|39J2zZLU1D)csH$kySBdyU<6)L`#oH#*?XP zwOaV~>oP%_@2bZlF$u^YXt zALk<4QcoJy=zoJ^7+Lf2d!NeWUZ7`pb=CW>w5=aMKG3l12tLdH^6THPMZ%|0Qba^f zNy*b*T3q}a_`c{buMI0Y)5fYL=%otx5=*p7Cc~H%C7sW6SqyoeI>VP|+%8vtljQay z9h}0Yu-H-$A2CpIWW$~n!DCJuis|u7ju1sWfYmP!UfJI-6^V7(ex6hpx#QB-Hj4JR zbLVxau0*4$CUxBnh%4E1@pF)$7j6a75pU2?2S>1%ziH?%QSrSSTKVI2wSY|Q(DclX z(_`0`j+8SVSM7U;hczOc*Q8%~-KbVnWPtbTo~bO;pQ#UZ>r7Ks7;YjgSlP&6T_hqT zWWK8>kAjjL%=f(N{iPxkH)NKilW@N37X(5SEx3vG>)bNJ3)b3$Iu?S9ULxq9o z#7uDCj=7-%YVyA}{#<>~ZTX|H?jw%HpAqBpO{Rw#)CMVm4thEcTZ2UQpY&?o;r3gL z=lTnd+EHVNQ?NM$3&kY7Qp3azr8Je5Qyl2D;#jqkziQjBc#QQV47PbmJ8Zk}El*hV z0~g+-on@o~hhy6*1dExHo*rU#Gm}fdu3?9_YM~!-bIvRzF-;YpO>0-(WOm%3K|4~w zv1fT?P+u5{v|xe{z0s2bYnDY7Z`Q@#?CPKG_FdG#*z(7Ugs`0yS)M9J_poF(kF?)W zrc?Y&)x0{&T8OJlUt;fGZFfO_hs98oT9Qm&TOyqM<@V?&j!5*R8@_^p*~^y|smd(O zYlw2EAFo@KxBG`Bc`UTI8rYZe<+W*p#-^r}Q$3Z0acZaB?axDhC6Bn<%i#QKx@Ke~Qn|ylH*e!g z-a~ZlQ?K0n1VMxhD&kbMw2wf_L+urG2qg#AcFcl77h zu+B!WAqly|blmcCz6T!bO`YGHRN!EJY_3b%*XvT~D%h%=2uxwW-4KH9oUvS-P|^1G z;jr^o{-%(Wz67;tlGGi!>`_Gpc0t?yZH2*>P3M1qZXE^f#W7~8?gbjecMFB$wHqco zDN;pK@UKYC5SDg{h_mSkQl8u3Dn+A>n3npubm}ci?@xZeKtTkTZ*EUh<QgzpI+ zzA=+&))rpe+A`@%*WDIIoxeIwJ3+$ZhhkE!2b(OI&Zi{$5$|fN*ilRb-_B%{9zA=N zCQ1oCG26M~FR;1%{*tpbtbgn8rR-DRRwp<^@ZGf1P31$LL|}3^#=c2RK?T#1Gbp(x zi~4B5#GM}-0!KmR!Q;9?=MCQ(#}Z9Eva}2|siZ&-bb>0nLTXIkrQmA3|(rX zoc_kIzBBEDbWHm_7bgqEK#5&oh-r7G2^0=GdElx=1sRi8v3{D$M&32nMHTfJ-W=oc zx~~i|Z*t$P=u%OgqHxZwL0g!t3?FItXK1*pp>jWZT@rA1NLWnTJ^ZVtfYr9Ubab#U z=@T+i#@%wepmuwLw0{e1K5A;Mt_aw*r5fJ^e8KI{VX93uVnG#$4v}wUJn*FPD74$s zR7-BM&K~T}5fCEoazjNvwTxElQ8=$J`NIzD!gS0P%wil;=WBd9IxSF>jb3fsxrG`T z{oPp<+C>lYU7WYP2=~IlZm6ji-Q6zCQoFy>mnU2ttFQ6zmluSFzTqhyoV7gjz)*U? zA}UUR=c%o|VwVZ4?*}yU=oi>koEF-u^%fP;N?^l2Fp#u=qcogj825et(yv%#`4g^- z_!cE*{ZSQ1Wl~{mE}%=OFEn)**rq7Z>DVVGG6t-;PnK}COf+0*+YIU58xY`niEua9tbciXCGi&9%dlNlodrHnnC0cEiYv6W{(5qZ7|eS0EsKT0 z67idfrADpEJ8ODD!L?Z329zMK!eG_M%tTRAU0)KbuaOUk-n5$!=P^<8pJ~640ji@9 z$BV1vf~Ap*S*m~EYwvVuG%U8Y0{KcwNgOQxYUJTo1({hN=l*15f4g#1v>P|b@le>=dYtRe}FKhh6giRXj(>Vfvf_Knqs<-eTK1LaJri%p%gUJV66-t5v6tLX*2c~Y`Lt*!1f z_+KkTR1Sq=kG+R<`8c+TJanqrTgnRhk*b`1>5{NDvaI;8!YkLIKjXtbw7O#1Qm;N) zDC~4}(ERP&`RC8yF7)%r%l5Fm`)dgkaUrOiFa7C(rx4VB7yri}M@~U%KX1XzAg({o z9M`Q!-vA~#_1F7R!m9}Ww||`8+CwsqPanvVKt3;jJH|Np%h(&1kN^7KbvGU5k?w&Yz-0y zzyENqD;+WM$#9@Pgo*APHjoC}Y#nr(($!i>L24yB5Xj1pw_r zD~()N*9o}-`|{QLbWA);JZX0JffRSCGk=;wVp5hSZ!#Y9D5qY{GbYUn7d74>dbr=B z*X*~y`I@0T3b3ZYYJd$WoB~oya&cGp0dkBwzf!}=+MaF>-D6%$n1K7W1iyo-ha}F= zDQ2Ve`ueC_1sN@wFBnPXjMWvw??eT^VEQVE}i~ zv6v#n#a$VD0cN*Wy@h)ai6{H6RNuI&|Fv+JXhmrBz8I=5UI}b;&_J)&)Mla?6i%=$?SH zt&x%G!e`8L0P}rIp0mO6X0hPWR<+|OnN=pVK4`ox(HYb?0JUuX<6=_OG$WbzzDV`M z7Pd&k>3tN8MNwa*NjUAT(3WTJ`(|n#DD(2#YpSVz-kp#I^pM{Bfz9mWPAEOSb!)tQ z4atxPlsB27z{1dMD2lP1Hfy)ai@2}32^3~Y?kv@%bFCQ-VffRTY|VdBMk;nh>LUj9 zlKV8ljGh&T`eA*%(%k}i%=(B&8VS#4K=r|%&em!wV9oMOK50$|8{B&Bp8iX)=RXEx z@fZ5IDx^Ls#1r;d1il^x7W+43adp7EcXG0qKKr1Ay4auGN0Lw6(Sd(4V=`kL#7O zu#3fDEn7{j*5JPh=Ur2FOT6&tVKD>!4xr;V4J6Xo>;I}iYWClR8w`Z|Sr;na===y- z2u`H*aTv633BUjF{>ox&wXjKd=5D*JqjlIRU4g%7-kd)kMT{U^fKT%>-;lj&aNASS z59t~_%65d5TYqzgO$p;m_y2kT|LX$!fAL?xKSf-=xNQ9Mv)=}{VT(DFcBxuZgmP{= z07@~ALpg@eyE6~zL;L1)6`HZV{YkQW$o&M(&Q#(=5&-_5+6jLR@7DH7R>_FBUhPyZ z87j6JxFmM<%9W7d{YDORgZdB!hW)xg{k0dZt%Kc}(W|O<3yNMd!1Yrki3=)MiA)GFF3E2E$#;*qJB8o+VgUjgM}yEq?40ncq{rK1*aitO&ZDH|-lhZ(fStJdH)^235 zq##vw=>wbAzQ}p=;pSAOnHfMECE-QqDVTbN33`- zInaYhN;{=1cxBA7;fe&@XK%for()kKI8|2sHnpwc!1KAmy2hyfe6z~0Umx>UI`8I& zg~i4uOwqv^WWUtuzIoFR#I#OkQ9;AT+t3el-T1dyHUo&z{pxNeoy_%)hKJ3zb2lk1 zV)xC!MgmoB2DglV$sNO;@7_=wagtug%H&3W6g#h=>}8Bm8zm6@FqGLoT^Y`yEp-`3 z{7cYVohhKA({Y1srbGoaG7LRW0mH-#t%1i*PfZT@hOJvkdMjavD|;TI>}5)0fL^fh ztVl;Xq&9`II%eop_)R+J_Ylgb>mUWFP0LD6TvoBg0QrR&YnB!|cBZPmh6hT=IA;FH z(5S80TQuW^)!SAzjen>+tRBvlRRXL+cV7~AlFN{^agJay~p3P+AU>L7ymt1EW zAi{Jv^<4x*p=Ny{KZ|l=Irmm-wfrBg^5FVP+_9P|tc~FuT_~cOiyy9+Ii!K>%QLgq zw}mjB`65e!W)}0is!{j~Jy2C(F)Y#uxJ@it&`U5@dadUXd~2q1?R z&4ekBGDjrVIadVHnFTY%I!Oi7A-F*0zy{O!>Udh}&9qE5d5yv`Q$XM_G85t8Hj}&u z!*-QWskg;dE>Uy7klHS_r%9(ch{4cO(@vp*idJP0C& zM4?F{dby3{aMI!{#$!1>APlM;L)c~~yzaSvzvvDt(g62}g9aX7IJ@n+Gf-?(3QEM* zkcPc1;s#g5y^+Q4GTVg+oi9>MMgGHOj&Ff1K0oe3VOxJtTr_?gc};c{0Qnp7<%#rP z(f$HP8g~5YW3!^ihpHN-{WLkmd$MQyZ zKXleR_oL@UZ|~g$>x1=n@=n>YfgF-m^?`wyQiqMtrBU?K+Ck@c9urOI#LNZ=NF9+ltsh9IU*D>EWBYL1S_H2z z$B;z63iO}OTB99Uu^04He+1RmDg4=f>%KGOw8KuphoTLrOB=E>3sk`szEd5!yJ_~O{u z;+#f*Wx_6ai~wWK3>p4+T*uGRjr15||2B3A^(8`ITWx}#im*UV`JHpb9=W%FxfTH& zBC76)fx+04H(74L_2V=de?+tbLC^-1#rZmWU5m!?Lk88>^Q4}BAcfRbo(xg~J7-=lS zIRvLMj=w+f@VRA|rB2Lp7pJJ=Iw6;?9Ozf~Zu$cjMF;uKqWXlNJ#(w{2%GQC`Knu; z6f)(>OUvLN{O-1AWPflxUkypV`GVt=42scrx)*e2o*_Arcw`S**^W#vX!8jO(D*TUlw9F9r2`sMN>G9f!{gO*jO}5 ztW~n>^UQjBx#axEJA{H3Ll=EU@Bi*LcGQQIk!e=Prq<&P#~5bi0jVmz*^alV2q~#) z;5dEcDNTZUH6QG+X`5M2HmZ8yIg1Vp4wpyg*}sn84kCp&HhDw6hOKh9i6~BatzsrxCXQ2EhX3N&6SW&*`xRk*; z^s~NuxkHR6o=#A3F^p|NakK+e)5NEIn+Tsef>HTHA!grxr~Q>aV8;UQY~V(C(oDDFIO|$UN)zO?QZtc&L$~NV$hu> za(}5rD&)&Qt$Kgj!uQyR!tNRD=`+>EZ|v!fd6>@y-QhUTK#!+vD_>&U8SB#bx<%T0 z>Gkt#e>AV}y9t#ZNi7Qgcws*Tmi%pQ;hQP+B_{{i%zc?OBplq+RQpRheKn2FMc4f$ zoc^!H*#Dz{U52>o{oIS?hCCj53wjsiG9NE5?lOoYWAP#cLd1%@F^oU;4Gm#?^EnCu6$)J?AbBA7{`kd@ z3CYOFz>ClAuo#q;oPj_@FM@3Zxy)(MfD&-rOeY%83fWl11Mfq1{62+fG#V6D35}2k z{`MfXkn|RS#mC>PtNf$}z~6m~!%0PQkF&SS_!l&AFYv?N9M{v{)eL+_Eso$9uQ&nC zh7id?1z9v5gC0U4t_irc_L+) znBwF90CySx{~!E+e3y2Px??VUo0;COIRh!Y`SBC(IUUl%&sXwS8ISzHhXf#RbDV;F z+o6Qx#F#7J!oi|yzJS0<^O}$vDX@G5>u%sW)aiRK!0K3Ql}4!-Y&y@TU}(hLdkbTu zqRId>KB|S)D`%+Rr~EdR;NK-a;YYRx;tM~uJaB8+@%!AObQdUcf~8LnVqlEZC%tWyi7Yj~KS z@*D7!Hv!v|x+(jwu*$;pBp2=$u$_F*>>Q}`;m-LLLKrN|m&6dK*Xa6sLA|nZpg`1; z1n}@I9oQq&uAcz^h&KUyz@($Dvh;1f2Qa|ry0a4Oc|xF{EFJ;?(zgaAY1IsGE=0#! zC@_nOOo1V9--+8ZGVb>YA&@BlXakA;Bmg6(n$7YQ^r+!Lwjtr?E(I3Q_wP;QE`^N+ z!{%W%vup9c2_)`wCK?#l7y1EYcrd)&E<22?`zIW>YC!5{UK6`k-z{R|8$=yFlAzc= zyCM^@eFx&r?SO9s`L)`EKmmQFuasAQUR-km=$toA%MTs;ab8J4_(SV~LhTcR38F_q z5uhc9T;T#flwqvdD?8-k-jbdA%g?LL{0*j^sni}nP4LJyq5P^CealLqf*8JN4$T7% zKa$-$=|AEnpfY_WE4ljc{dHYBO~X^)Y)LmfvEW;IiTn-2}j?fTXWX#cnZ!`|%2Z@Y!y$ zwlAQ))B6}3TUu2Cy|g}yc9QGrD8v@1g6|*lom|1*^s9+`^jtblD<}Xl?{YDFd^iUh z{`yJ71bp;&#}suz_wo$uqZs8MaoJ!(Sh;_$Hn8u3*wpfRyT59dHWOp=3Wz0KMLJz; zajN{yy#P<$*UEX}jg7A!df<8H;c0!Z>!Z`JqR#>6N!UwC4lba7feps z4N7BR1+b{h$CY+v>c9kG{FhFo$3=$s)8v^skZ1gLH{2e&;@$gIs2g>!vyd23kL{hC znlf-+1Hqu*(%|CKv`kDy)bDTl&)ZvOJTyzSlt$SuMs;WFwU;~dpFPL5*w?88P1Y!I zt))Qf_k1mBxfby-+yCVd0QC_p7PWr%(R^GM13h{Ts4DQVKnf$@w7ag9B#3}UD3Jqz zoc{c#`@{ahN%RbUc-;udS2BICC!~)r+;Gdf{3u_ zXyzf^x{c(;L5-Bnw{Ncjt%=%~Ma5|r1a<(J{+z00$uT|~g_VE6F_k*AiqpF8-(NdO z#}Tf4W*xvN>s_~u&xsU^|Axy=wBuT+H!AGTInSJbfOB`Le~zA(xN!HcrC39 zn@_tg5Q!l8ESXuHsy#oSBe-U0ZNifkcAUt$?|G&t@Eymm>vNW?N@Fz`^yFop@%lF4 zOGQAXBe{)M$Hm8F?(%f$WA_&#DUXQWpYj+GBNf1XZn4$GvyIu%4!gA~Gbd+L zAAYcLy=&A$=zPTP@N;W&rvp)TeZ6;b&vLb6ysCAC?+PSe(N%w@Dka^WgU@&Pk?qkf zM=6J*tu-yeHl4MYw(sM6Z-A4pc05}-)6?f46-CoseI zU*$pZD26hCN~Dk|X*=JuKHKSbljTm;sdb^PQy$k9rcZ7Q1gkKI*47%D&Kuoko@xBF zRPj;m{$qolzUj9qS&~A*d*UQx(jX1l1LXQ)7k-8Od73_+mBY2zjaBvfFy!cy`F$ucT6=>7S}-r@5{b5QO+xQBhDW3ATUP zPiIgNh<1-l1k+wuYrU>c=%&?pK6ABHlXvMcm@GV?{ka&%kiaubCq!)xNs*Fiiig->c745 zZC;9q&RR}Kd&}6B$gzs;LwJVXEjDK!!=)dK*g%Ymr7z+h!9nqPO(a~aa>G@M z+De(4y`b6FRK1t92bzITD5%yBaeJa;Z$~fv})t&g|)&E6$m{;sjvPi>9{~+Z%M#Yr(MdRSoFXvS(Uj{uJn}Rc; ztbJ<$75m<97n^eGI7?P;smsCFlRL(E@r+C>_P+_=@d%OLIxfHG;HaxbD}mPr1)cHz%*nX*2uHQ3X`|Y0*=6UU>^udG1z}9>!XFbkQ1GXs=luNBKzh zf_AHh!o7)OF=M}q9Jk&r^dF^=8G%&dSpA+~SaRGt%Rkx7mMLABkRTK!xRQPYL2B{w0C@BahqenWjkvxBJ zD`Nv7j&re~lo2gP?X>tizw4$exBb;*ko2+T2r0N9+tCswVOt0Np#f-FI(8@y`1r{3R*LxmL>XbRWnrZ7+P-I}&*o-J0AE_+46Z^hB ziAQil2|+<&*I5Ymr`1ILA)xMKuel8BT|rb&aQl}V@K3^Hg|Q%$q@MFa@;Do49W$Jj z{9z6X>5+L7LPr7^ACc4LCRfF8IS)s+(Q*7={Q6iB_m8w}R{a+Ql1yk7b!|a_EAB1{ z|HqqV%a30Dy2j+GY7`3MA(HlMlT~~+sknIZ^U7N-QN6TWxKd9-YZdVtczNWE(D)8&8o_0XWop#<&#iUV|m<^R?ihFk52_yyJ4-}Yuf(A&mCFOLqpm0_$g!r1!IY%3z( zu77fcNB6wNPg;!-!YcHhr?9;HsaoDUe}xON!+*ks^1hwEho7HlHOCCbuPzkyXEX#A zih*dW+q=7lhDlu+drlyyte;Wmnx3IqRH{~=mSr2dT5-sA2*8}e#Y>k0%(xQnW#(ei zRwrVwZ#aN3b*yv#NSp`xWqb?A>7TkQiNFufYkqVRKU8j6`owJ(&}HUR;ye{Sp%8E$ zq|JT&myQPQEKCg>2W-tjNF(P3aVx6?P>O)GXEG$!w8sOoaBHu(J5?)UwRu5Y;|#Nk zljL2`ZZcT8(iW2Zcb)$i@Q~THRqxJOs9&~C6FQ?R-hmx1-4)Jb+<5+$39QA`n#qa+ z5FF36K>&)~1=Qpk5H&De-u74?FR$aZqTyjekNf-f#TV~?0_ihj!a#Td$mBU3PA4E`rK6$L`c^ei7tUOp zIjD^g&et&if)@Xn`P%T@q!kv5cm9`IyrTZW9mQ`OMXa%~%YY z@Svo;x1c@3^H+y9nQBUKZ297_0_v`Wewa;)#s1;rM{^YjV5+7N;aXlO2$LvbLZTkY zTuxJ|mgEQp0pFom=-_MBAe>)1I#lL^)-17A)&pY7qi!94kP8JtR$L9z*5>jjmB1AM`xY$;_iI<= zCv)Dc^oUU$?2Y-uRwu$Dl_Ha3F!uk2jrZYv9WU9>MGN2yqUwS`04k!o9`#A|2qf>m-s|`>r(BtcdA+BAuI!JiCMi? zl%1V>f}Cy-za6}V^0G2r8MLj67akzfcGZpfh~>G5J43neU0p zkKZR73J1FqxUx1gqYOweWw5-~;s}DC6W`uO^V_~;jtPk1L)--0Y;0*sz;1E5HNo-x zIWF!PHo18^CMI>>MsT+z5X`tdqLsc{nFIT6tE6T|ox@AL<758aU69WJm4lqe%D0J91pQZ>uycEK)1KEX;|J*xVQR++niC%6gVO3nZ}hN-f#DVuRV(Af(RnzW~u!>)rJl5ODy}_m5C-@%QfeHzhp1F9%j< z>s8)jCuccl>Gpam-y~8aFtM)gmn_U#an^DDVq>$6*4Jm_AS+j~J<7V_re$0Nf|>w( z&AO2VJMd;Y3757lJSjUAS-?7=1wG6IaTciuumQkqOywW#vus%ai@Y zGiwtLUVDMz1tjA5@2Kps6K_^OgI+dvm*<`srmes7!C61VW@_ z$GaV6VB8#)jHCZgG^aaKa*JMjR2=RaAs*SzFRFGN20;_Q$f)>+LGQ5O(U=f{h{5Ws zwaIK?IFj*k1}Y~!-H?+-c=|4cg+Js3>0975HO=LXrQ-b5x9BqssKJAPDG(gPY4{=@ zxx#?jn3-wwxBkyJ33$l;d1*%g7GA|Ox1Ff}4lFicJ*R;k#&5UD|N4cZHU{^UQLN5a zk*LJADGsz1K;hrrN~)^f*Y|yq7U&dv3<6#X{>=4t;VhwTkDU_C2dDfgbkx&SLcxHK z^lY{8cwwKsls+R13)*U0O0D*5&epc;G|zFPdh{*P5+5PtCoK z2zEN|IL)#8m!dxUSv+zrf8+{1sJ^FKC_Ht!K(A$~S2>uxUImw;sRkjC&b+jWS=SBT zCJDh~s^%g4KYoy$!@b>hS8+|YGB+dh{)zN7H%z>h#aEh#|+Rw_$ z3jGzB0W#5iUJoP?FC}RuO_a)9Mc(@Sd8g>TV7f}UMxVfzdRc0=pd%Z3yECVC>%cH& zOmuVxEi)aRD6Qnp#QCYIshOFSdIk0yiG2_vwWuS)ClJPW(*hl*TpM1)FymXc$!%zK zmWt#PySZ1bJ$Bc{;=kq99f2#R+QPZeFQ*O-utp5K_@0@!r>>5Q6A?)T(1E)F;JNEU zk0J`piY&O{3l@S|z6wqh4hG;R5WtX8LPANF7Qg6LcAn?e(fW}0Xf&-Q10B3Ya4%gv zWS10Cj|iaNwqOLl_b0m(gB-BPcmp3d&}w} z7c4huF9|Oa?uf)IA&OH&6SYmxyc(v2zrQY)^h_IQig|TeP~V~ZSt3pv{@pa_XJ6M{ zJ%AmmoW9-h;YvS?664mv7Jni=$7}Qc{A*y43}~Jmfc^IuyM5H<7o_mWvjpr#^eeZ^>PNu*sI|rwI4e4Us%GaLIMTuGlLCh$aZ^57E=; znFCCYzW3~L63AGgzv|UKB1k$`CtV@2gC)1Zy8)Ut0lBYkDB^N0RQWdQhjCAE_fCTc8YRmpP)dAkQpfl z>euVS0w}SMDTl#ui1A+1LCl$Ukh${h2O+T%kWXD)Y$;n;xCZjPba2%6RzU7P8j zB3!pQ=$(d234m;_5GX_{aVf}C(VESDpyf+FiZ!iX!C!=!;CQttp3MS^rQIScJap>) z`rvf|YG*0)rwuxY5XmuaT<+I4#&XQTmwZsMqpoQIi$j`4!JTLJ>y>#)QW{k?a5xDP)f8#M2xa9LcI6Pthuw1ue1F`HjJK_FtYNDcH{< z!PL~$Rbf|)a^}26QZOA2@g`@^5&n^Wu}l9lJcR@=q&U?FaWk0#W>ajVXhWfKr%Ed< zr|7m7%=w1b4V?$$f__WAhOx>9DPr-LFLKu_oJJJ~z z)l0mYyi)+^lEf3hTC9YA1bBK=x&z3N`fCx*6@(jsvR`xrHS#yV0u4OtJh0$}(Z4*L|j%3KbeadJoLS z@MPjHx!TMukZ$3nDJJ9yNxn7z)P?WMkl0kzKNkyV>Pq~T8;LYs7ouP-@63w1!3>V| zOc1Vz7i7$4os0v_FXkA6c>o$rD=zPH6)C0nvoPC3+;c^whn^<^gqmXR#ra$6t!ZI> z(@B#NImG}kCo1Sml-Q8pr|#%4LHYad<(s`mBfwxb=J~B$3^(@85$$?2iH0O{8FHreGFD+&Pz2(vxrUqWs_ZUMyn_`2xgj-#!L8LKfiyGCG5 zT`jVj0K*MxZ$lSxE?vasGrsGO$Tr1j(E zZqZKKZMti=UndS+OAvI-elr9e>P@RdT)uSadR9R5?T;}I%#Hxw1>-1Dbr{X*bZyLu zWswwZCXHI%X{p@z4K@#9QQZW1a+WI7#MWj;?QmF(Axa@g^W1mScP?i-uHCNpp@Tw%bN2{BP`Ll{k(JxsqujJqI-$$hN=M};=vJY3-_() zd?JXrjO4_E6MKq$6)M%C>II zd2nz{N$SlcF$PcGptg`iNlhN+y9i0?t~6`oR5=|m=38&yFsFAt&?7wjr^AM}8VC#b zxrrj`=fDvDEu(`8&qsA|FjUjU!-M-W0Bk6milQc4{N>3Sj`pVCD@v|jK9=`!7^}rG z2Se^4PyJyaV}pWFi|y*@2Xfl_%lVD(%;ZrZB$PKG1qY=2AG3z4+YH#Kkt>6*v~?=m zbq9K!RB;(p3f=uBB>&-NL0bfLVW{j|OAFi_gWP^@2xj-a`K3XesKM%YoM>QBeI~}% zs3^|=B#c^p28P}kbN>zf|hz}uI=n>+R$W) z%O@+|9lk~)``%d=JjKu+IM~O&ckKcHHScYk0z-;@EeExJ*TPUBs}&FhX3Xs@@-DdowcE>+2PR zmr*fwtxP7t{)EoQfJDqAYXtGBQa%!@P*1`wwY6fowUMy^bQ#<(JrZj&ByK$V7$D|H ztC}n)bJxS8fK}(v%WhaY`=P+7^ZF6HbiofwJY=X4le}&0IsT*jwZR3155V#P53%_RIDz8=J{xze@-n-#v4%c&JMAtt{AQ9^ zsXrzB^A$E$`A72Z|9H;WEa-u~pLqK)bYXxu3nT>t1HXfm7{l+$hnVi*Q*Q zqx}$O;YCHSm^Y)Xs@ld(k!k+nxrP;YTd2ajhlU(X-5rL~*5g1Er{=h6fOT@H0w;^4 z@`4jEkfCY;MruH(sGkrymsrLZzcUbWbyV(~{0+KMT1-et2<^m~3wU)Em4JmAZ}I?84Z&kP62#tm>btA z&TR=`kr8mr|HNbQo;&TCi@x#3?3)eoy5ysEMKytE6 zl4rKtPPIL}F6Q{_dQgkn+UC>4nV6VXmk`$CY2E0$+bKjk3QhmU0dP+sqb_KN6lp)> zyP_ZHJ}`{enW8A2@4QlNQt4q=0^IZC3zz}sFhFrZl^b*2*5Lr=~j75n3DaLBH1n#9fo7O<&^j>XN2_zEG#3zCK9eVcXjY|L8BP z8?G0`S_o3A{eneZz~JvSlEu5xYSI8-Blj)Cil8(60@Q8~iI_OO`Y;CYUW~z?MZ{3y zk7qYc8mK=15P|lT6BmCB;9wBX&~3fCXhSR@LLiy}reQ(+cZ?doE8|~Bi6`ovW7zUk zObiz+jERYvHFeD2pCY{etNrtn=>0~Cj3)hzYwY$-Pn`kg87gx-T=BO8K8|T$$67}U z=iDBsLOqjM(^<7U(O|f5^EX%U*Tp;+Ps$Q9xGmxZ2<1{R_JPS4pC_c>qN1WmuSHKKgg^EXy3WAE!NgYehYA|2M7rn|dyW|Ly~ zW6Aaeb=lzEnPfn`&t~?aO!4SV9smhkJ|_V0!4u;HL?Kwv^OnRD)1N0)p(a$lY8TA) zn(KL7vaCK)o&BK%z)tt6s;(9l5ebKJw(PpDO(DKY;}qlH2Ny~5el$!GL<&~^oe0bQ zldRt3EHzeP2)#U@qWm{>i|TX3EBHVkpLXvqP7|8#T-X#cZ`-zfL@{k6YIPEx=2Dxv zLR+KPh#+xCf_pPTyO5?HpYc4nGcJXUK?jBA;R0&!rM2HJCQwiv531+8L1%b9V+9<$ z+S@t!`88^hry#`v-LAp0h_7HaHZl=RbN&@R6M=DN-~Y7M=kzY`!xgdeT@%%@2r%jo z)?4OokK{k|Q6i|usSNH|8vd-JBEuGP`sOdv>YuCQp(#n$^{t)pyG?E2V2=RLpcJvO z-xFSW0-D9S?99v}#pu0hG0)dv?$vdH5`IqidJ7hdJsOXJd~hv2AGHsV85_LMjScvK z=?#rhEE@`+kO;mvud>xVETzH21aq&vA|7}Zkv+gkUz_y37e*IspVnmfpw85M5vV}i z7BWOSL6}{MAa7Ab(4)WK|((02HG25#1AB3A%}Opax+lWS;h28S>i z?nsgok*(f+waRfNpBSND;ZnS7(A)xB!dbN3!Fi#efm6(L8m}s7YNB`fq6!rgC1rIA zUv-=O9y7`fIS(|C%mu~0>JV&c=OiYidtg8vDe{e)`dxgy3-Z%uXd>W;V36qrm_I^7 z&QpB=K`=jJmd3iYzmbO9Y7XFcZNc8j0=GZ#MPG zkq32J_G2PgF>M$?QmK_@uY+U4*5`YlYNi2Yzt=xsR{D+9WCnLwB3M7%_6xIyGUxk& zQf>O?{{6T<^Gi%7_7IR3j$|qx6W7$#Jk@byMgdf}L<TdOgtz6z-N{6goI_|T_(rpcaYDBlVRLaX<4BJZQ6Uf}Lt~uB^9294q`iL* zUFlSK_56F-dV^cvFC1Tf3f6>IOjypQbSFtO# zaE61FizK}kzVhUBC_Pm;%IFJ>7b^x$CKF6IHZ)1R)@_tcvNO|jGJc$1 ze==;WG6;%$^EWR-7PJ$6B+gq}X8OUSAoNxmHVEsYG!FHp7}mI(lvtf|mk<#& z-(Mi!9Jj9MPy*V<&YgfYj^{!YK1ma}mJzu=4$i!?snDVq`S*)np1i_-Xv=U#+&rFeK52p9pK14 zWx|s)Csgo~ut6$%maiAMyk|i)8jSmvjsaz6I?6ghvj_un8Nox`#;a}M>Pi?4>cji9o~aT@>k4Cf zQI3YJ|&=3|rzi8{7{*Y^KV_SJD!zT1~3EnOlZ-AYPG2uLdk(hbrn(k;>;-I5X_Af3`6 zNVkGWN+Tcw(lz_|#XHygyEF5df8m_>yie^|d#(Lk?;ZkfbrFywH$@(LCeM9Sn2e}m z2`c`FK5CX2#nIXIt;eWycJZr4%r3N3%MXtNLiS60N(B@4;$ABi#e1^mVhX`s3f zx{`Xg>hpZLW=u9Bds4`#K1_d*a#7tKhzYox^-#!P%n=9q|H@bL)@f)%R^EU!JAb~X z8>3TFv{AUI>4|(~ACg}ckFGQPpA9W0K5E6)IPQ#&=rnrra@rMslFfEdAF7P1bt&<4 z>r&K7V+l$yEByqJ}OLrZ)7a0B9@v(&+haE12 zPt_M=ne?Z|jw+%wsG;~Jz-wO2Xkjx72>@_`LhCUnvTl*xbLG`Ag*St@eqpt! zN}Vs6PF5pyrx#>)zhzi}Ed7>Y*~`~_0|Dgce5b}N`abF;3o_2J@DaNeLxkGu(+2%W z1EO&TJv|M8BW>*p*t3WhD|&ZdQlF)@7!u9O79Mq=F`)flgjZ^j*?*I|yZ+TuV{Lbx z#g={!Ss-CNWaLZ4(O4fsLAAB_JODVQxDcIZhfD+80lGjOZwA;8lr!e#GG z=5-qXQQJ!HX$p!4vi|ms#FD4JX=!Ow+Qpn>V`GqAxb9tQ!vD9n9J@7ELv-2oCf)yN zv%Y(#NurcM(FEbkI?}M!nck&+=vbX?o_+MR*ho=B6s1%CAJ-WvYzvOA<&cywGP~5M zdsg<*y?cn-({F$MfmhLYK;TjGqtUPn$HKdPSL=e9yv`VIjHC-a~ z7c*1|XR={EA3L+-X;NrBg!_-?`Ro>f1^j@HeyNv_^R;>gL)Tmexa4ZgaU4F4f|15F zYE?BgVqDzW>2|3)idVG383L@Y0H9bcCX0N+MKU)x7aP`6mhgbCubsL}wCuh@OpbUN za4X0vsg*&#fbHdxes%MiX&giFR=FvRvG9XqtB|tc%+-M0LDQJ97fRxP{|~bmo05`J zMp7Yn*}jHp7Aq+J-d_*h9W>=SJ;boB4MYx6%@w2Tnhl1It(^Hb({D>-AS;TKk~)*h z|GcZ&C^T6)?}zS&gcas7AIa~qI~Hw#~n{p&OMD}jZ9?CPc$Q!`6!%-ZAp5BK@0pX?tWFdBzgn2)Tnt5L5;HJ+&8;|yBv zuHgWaLx^zihc?Ej{bG;fl0yyqDOCB$_{){D^dtBkTqQIdP7W2WxF7G!WXY%XUBko_ z#rP>MC3Q6;Q?p1r$vA}(wQytNJz4OcI-?BEAh1TX0@ee?e!12UQ8GLqG@XA;Aw@eg z!4f*1sLWa5wwy#lV>yaeb}<@ivCw1=r$B>Sv-l>#fl2?Oq=dhuxOlnsqyUc-dDn#3 zS-ruhY|oQ`LM=XqI{~&YZi~)-t@!Xcf7-0Fn%dH!K4fKB*L5Mb;p$cNS|^+61mf)p zJF5VU6>rxpe%cS5p2s1@^2Iz~u7uP&8tr`ltiL>vT2iup_$$cwT3P7uR~E{}&S>O- z0G{5?!64E^bq-C55^VB3QNMhZhmv7EMBkpiks~u0Wl7=Hzh`wB+3{?Djyrfyi!m?i z&s1Xug@+ft@{%y*NaUpmcP61X&Nb<)Zcfr+-M4QmeWEUBpwC z4oB~YKQ+Kl>U#3MAayPlbeoF!j?dmiA}(1aA^20_C+FMi4d@>qSmF|n%x`#2>)put zvI`Ze=KIa2R%0AXA48uE6Wo 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

7U;(81 zmhb8hZ5F<(zsxsvJ2UHV_+V->)mQS7=2CBnK0{^k2f9N8WM;7F#(e#ctVf#nuKuU) zm8AAtkyPg>5J3L7xF9%1t2sNZ`T`LVC;FmfZ9o>QT++qj4jIR0` zdl92a+GC}hP@KKNER|ZIS*m4Pfh(!>K58{(J}#d0rbBpc%>?EWwEA4nHlNbOkaU=| zT7CVKND280bnpYhw9}d39whJCM3qyaCdqiAF$*7H2$>Q+wx)gG^3;v213p!|o_#3c zzVY*OTTX}H<9=eJ`Elw!iL8c{#uL;d$YYoAD$43!JL(u`p*^zxn)i_RhO)w^U?FcW zEN1}_x&o+N5N^nL4vM*n3+KxN-ROxk(8hs*@dKnTMPF=G`vAfgq&OKKSj%n|k`3)w zFvmG+IPO}gNHsQAEe5_uCv|AM7-%nLPpwJRMd$#!=Z(hEDxYJgiDfY|9onKMTD z1F1AnHY%X%lDsJrm3RU@YUj7~6Z@5O?WiZp2Efn)S?eNg{6NvnUQjLhq}JKlQ<8a5 z3IX$*6NGrGA5Z&U*VDbSEVE5=QF0ns)aA2+V{i0F7P)&jd@;oXX%Zzb-N|cQ9PW{U zf}3*yHQhmP%7n|*{)nj)xCrJB*4e6|8wiuxtX$kck(BS*DWlzHnv#H@e7^zxun`lr zk5eQ8J&?{V15b>?`siT1Mp;sS7{mo2QYj>WC$ef!bb2WNiw)}HPLG`>duZCij7L&EoIo_XrPre3vpuH9o*-0aX|EdIG^YM+|@w< zeE``8?A{20aiLEN4-F#AWh%beXOdltn3qAi>`c2x2^%-%CC$T2)wqqKRk@B$N@ zVg()>SKE-Z+ZXMkG4*3L0LYb5Xo6!1fup>c{fRbT^0|%Ka=TEQwBhQ>UJ2XH;H{F4 ze7>aB`$F7eT$&^Sy;3f80a9Zg$dK%jO%TMW^|kKaKoN)mGXr`d za08wVP~SjtSq18Kv%38u43%cUz+bd8I)OMgtaKmy+Fuw^yMUL8e$(k=_vTWn3WOkm z?nH*SNWdWDQ;+B~q0&!n2f^k~BPxLo4bZQ-IN>y@S2$cIenwNH9yw9iNu{J6VYNAl zEEE^f2e)jWnmeFDa5eXr`X@y|w#*c1v!>b?JcPtCxFedarVpH;aISdQHX4_`)nSca zofgxbT_e$qqmMsfKrORPl0|t?NAgwaac*%d-0S)Cr^tvWH}6fy6B(k%Yz+oEd;@g{ zhaSlEEbf9kuz0ZREWXz&GroTdXR7Xq?6OT#P;JTK!wtke?O8HlBo7t&zo}O^GGtcj=J$<*S>>L(wer9jAtNzwKq;M}ejtkT*HX~ln zrrv8Sx8v^FEEi*zo5DAjG4A*E1_`VK3(bLta`KlTtPBW)MHeEUXx_`rrblY(ZW7XY zo279eZg!%1o-B))ftGwFGgPlXsK!yNEjS0{>EV1tML(Q2(MDf@7STaSq%}dX@Jl&{ zUBG!XNQP05T7DyWTsp3N|7az*TOoZg#;3fX&35jFZg*8IU@CIW2ydUlwJ2P}K)xK;uXjZ@m)s6(Jr>)^Lpi8-&1Nl%&?lToyu6S^xEJSAEbhF-9phikn zm73`CY*En6!XiTMbthby;fRzo^Pl~ePj};o4v6uUz&ZwpkxbXZc>2qmy(gZP9+d?9 zs2%?s;Wj>Kh%vayN}P&C$GijRxsJ)v%QMSEkT(Q2WTd-aTz^jWQROaLu~}*Mjvbk- zio_irUg!%iRRNV)@HaAr5q&;7?cqSl6(Eo

sKQS4 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 Rc^U%{c)I$ztaD0e0s!dz!;t_0 literal 59199 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 diff --git a/fluentinterface/etc/fluentinterface.ucls b/fluentinterface/etc/fluentinterface.ucls index 3277148cd..aab2c9ad7 100644 --- a/fluentinterface/etc/fluentinterface.ucls +++ b/fluentinterface/etc/fluentinterface.ucls @@ -1,100 +1,100 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/App.java b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/App.java index b9e5909f1..f7352fe39 100644 --- a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/App.java +++ b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/App.java @@ -25,27 +25,12 @@ public class App { public static void main(String[] args) { - List integerList = new ArrayList() { - { - add(1); - add(-61); - add(14); - add(-22); - add(18); - add(-87); - add(6); - add(64); - add(-82); - add(26); - add(-98); - add(97); - add(45); - add(23); - add(2); - add(-68); - add(45); - } - }; + List integerList = new ArrayList<>(); + integerList.addAll(Arrays.asList( + 1, -61, 14, -22, 18, -87, 6, 64, -82, 26, -98, 97, + 45, 23, 2, -68, 45 + )); + prettyPrint("The initial list contains: ", integerList); List firstFiveNegatives = @@ -105,10 +90,6 @@ public class App { prettyPrint(", ", prefix, ".", iterable); } - private static void prettyPrint(String prefix, String suffix, Iterable iterable) { - prettyPrint(", ", prefix, suffix, iterable); - } - private static void prettyPrint(String delimiter, String prefix, String suffix, Iterable iterable) { StringJoiner joiner = new StringJoiner(delimiter, prefix, "."); diff --git a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/LazyFluentIterable.java b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/LazyFluentIterable.java index 5adfa83ce..560b10189 100644 --- a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/LazyFluentIterable.java +++ b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/LazyFluentIterable.java @@ -1,15 +1,14 @@ package com.iluwatar.fluentinterface.fluentiterable.lazy; -import com.iluwatar.fluentinterface.fluentiterable.FluentIterable; - import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.Optional; -import java.util.function.Consumer; import java.util.function.Function; import java.util.function.Predicate; +import com.iluwatar.fluentinterface.fluentiterable.FluentIterable; + /** * This is a lazy implementation of the FluentIterable interface. It evaluates all chained * operations when a terminating operation is applied. diff --git a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/simple/SimpleFluentIterable.java b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/simple/SimpleFluentIterable.java index db7a31954..19283152e 100644 --- a/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/simple/SimpleFluentIterable.java +++ b/fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/simple/SimpleFluentIterable.java @@ -124,7 +124,7 @@ public class SimpleFluentIterable implements FluentIterable { */ @Override public final FluentIterable map(Function function) { - List temporaryList = new ArrayList(); + List temporaryList = new ArrayList<>(); Iterator iterator = iterator(); while (iterator.hasNext()) { temporaryList.add(function.apply(iterator.next())); From 338ecd1658c2d49c6395aedacbb4f7eb0aa2fa57 Mon Sep 17 00:00:00 2001 From: Narendra Pathai Date: Thu, 10 Sep 2015 15:26:47 +0530 Subject: [PATCH 07/12] Work on #208, categorized factory method in beginner difficulty tag --- factory-method/index.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/factory-method/index.md b/factory-method/index.md index fa30a4349..8011e42c8 100644 --- a/factory-method/index.md +++ b/factory-method/index.md @@ -4,7 +4,9 @@ title: Factory Method folder: factory-method permalink: /patterns/factory-method/ categories: Creational -tags: Java +tags: + - Java + - Difficulty-Beginner --- **Intent:** Define an interface for creating an object, but let subclasses From b12bbb8e0052e99136165be79c550482d999f67b Mon Sep 17 00:00:00 2001 From: NooBxGockeL Date: Thu, 10 Sep 2015 17:37:04 +0200 Subject: [PATCH 08/12] Work on #218, automagic website updates --- .travis.yml | 6 ++++++ update-ghpages.sh | 22 ++++++++++++++++++++++ 2 files changed, 28 insertions(+) create mode 100644 update-ghpages.sh diff --git a/.travis.yml b/.travis.yml index af275508b..a59370c30 100644 --- a/.travis.yml +++ b/.travis.yml @@ -3,12 +3,18 @@ language: java jdk: - oraclejdk8 +env: + global: + - GH_REF: github.com/iluwatar/java-design-patterns.git + - secure: "LxTDuNS/rBWIvKkaEqr79ImZAe48mCdoYCF41coxNXgNoippo4GIBArknqtv+XvdkiuRZ1yGyj6pn8GU33c/yn+krddTUkVCwTbVatbalW5jhQjDbHYym/JcxaK9ZS/3JTeGcWrBgiPqHEEDhCf26vPZsXoMSeVCEORVKTp1BSg=" + before_install: - "export DISPLAY=:99.0" - "sh -e /etc/init.d/xvfb start" after_success: - mvn clean test jacoco:report coveralls:report + - bash update-ghpages.sh # Migration to container-based infrastructure sudo: false diff --git a/update-ghpages.sh b/update-ghpages.sh new file mode 100644 index 000000000..7867150d6 --- /dev/null +++ b/update-ghpages.sh @@ -0,0 +1,22 @@ +#!/bin/bash + +# Setup Git +git config user.name "Travis-CI" +git config user.email "travis@no.reply" + +# Clone gh-pages +git clone -b gh-pages "https://${GH_REF}" ghpagesclone +cd ghpagesclone + +# Init and update submodule to latest +git submodule update --init --recursive +git submodule update --remote + +# If there is a new version of the master branch +if git status | grep patterns > /dev/null 2>&1 +then + # it should be committed + git add . + git commit -m ":sparkles: :up: Automagic Update via Travis-CI" + git push --quiet "https://${GH_TOKEN}@${GH_REF}" master:gh-pages > /dev/null 2>&1 +fi From bd89530fa24dcdaa619e51f446daad000bb2fbdd Mon Sep 17 00:00:00 2001 From: Markus Date: Thu, 10 Sep 2015 17:55:05 +0200 Subject: [PATCH 09/12] Work on #218, fixed git config git config must either be global or inside a repo. I moved the lines for initialization of git to only apply to the ghpagesclone. --- update-ghpages.sh | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/update-ghpages.sh b/update-ghpages.sh index 7867150d6..63ac36427 100644 --- a/update-ghpages.sh +++ b/update-ghpages.sh @@ -1,9 +1,5 @@ #!/bin/bash -# Setup Git -git config user.name "Travis-CI" -git config user.email "travis@no.reply" - # Clone gh-pages git clone -b gh-pages "https://${GH_REF}" ghpagesclone cd ghpagesclone @@ -12,6 +8,10 @@ cd ghpagesclone git submodule update --init --recursive git submodule update --remote +# Setup Git +git config user.name "Travis-CI" +git config user.email "travis@no.reply" + # If there is a new version of the master branch if git status | grep patterns > /dev/null 2>&1 then From bbd78649278cf5fc719cff04d2530e7fe964ba13 Mon Sep 17 00:00:00 2001 From: NooBxGockeL Date: Thu, 10 Sep 2015 18:43:23 +0200 Subject: [PATCH 10/12] Work on #218, fix push command --- update-ghpages.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/update-ghpages.sh b/update-ghpages.sh index 63ac36427..82486d5a4 100644 --- a/update-ghpages.sh +++ b/update-ghpages.sh @@ -18,5 +18,5 @@ then # it should be committed git add . git commit -m ":sparkles: :up: Automagic Update via Travis-CI" - git push --quiet "https://${GH_TOKEN}@${GH_REF}" master:gh-pages > /dev/null 2>&1 + git push --quiet "https://${GH_TOKEN}:x-oauth-basic@${GH_REF}" gh-pages > /dev/null 2>&1 fi From 9ecb1b25462402e39cdf52596669789330f9105a Mon Sep 17 00:00:00 2001 From: Narendra Pathai Date: Fri, 11 Sep 2015 13:08:50 +0530 Subject: [PATCH 11/12] Work on #184, changed category, added difficulty tag, more real applications and credits, added implementation approaches --- fluentinterface/index.md | 30 ++++++++++++++++++++++-------- 1 file changed, 22 insertions(+), 8 deletions(-) diff --git a/fluentinterface/index.md b/fluentinterface/index.md index 942867933..27a4d1a26 100644 --- a/fluentinterface/index.md +++ b/fluentinterface/index.md @@ -3,14 +3,25 @@ layout: pattern title: Fluent Interface folder: fluentinterface permalink: /patterns/fluentinterface/ -categories: Architectural -tags: Java +categories: Other +tags: + - Java + - Difficulty-Intermediate --- **Intent:** A fluent interface provides an easy-readable, flowing interface, that often mimics a domain specific language. Using this pattern results in code that can be read nearly as human language. +**Implementation:** + +A fluent interface can be implemented using any of + + * Method Chaining - calling a method returns some object on which further methods can be called. + * Static Factory Methods and Imports + * Named parameters - can be simulated in Java using static factory methods. + ![Fluent Interface](./etc/fluentinterface.png "Fluent Interface") + **Applicability:** Use the Fluent Interface pattern when * you provide an API that would benefit from a DSL-like usage @@ -20,9 +31,12 @@ tags: Java * [Java 8 Stream API](http://www.oracle.com/technetwork/articles/java/ma14-java-se-8-streams-2177646.html) * [Google Guava FluentInterable](https://github.com/google/guava/wiki/FunctionalExplained) -* [JOOQ](http://www.jooq.org/doc/3.0/manual/getting-started/use-cases/jooq-as-a-standalone-sql-builder/) - -**Credits** - -* [Fluent Interface - Martin Fowler](http://www.martinfowler.com/bliki/FluentInterface.html) -* [Evolutionary architecture and emergent design: Fluent interfaces - Neal Ford](http://www.ibm.com/developerworks/library/j-eaed14/) \ No newline at end of file +* [JOOQ](http://www.jooq.org/doc/3.0/manual/getting-started/use-cases/jooq-as-a-standalone-sql-builder/) +* [Mockito](http://mockito.org/) +* [Java Hamcrest](http://code.google.com/p/hamcrest/wiki/Tutorial) + +**Credits** + +* [Fluent Interface - Martin Fowler](http://www.martinfowler.com/bliki/FluentInterface.html) +* [Evolutionary architecture and emergent design: Fluent interfaces - Neal Ford](http://www.ibm.com/developerworks/library/j-eaed14/) +* [Internal DSL](http://www.infoq.com/articles/internal-dsls-java) From 3ebc64c5d689cd200d979d36d2895975a778b8b2 Mon Sep 17 00:00:00 2001 From: zafarella Date: Thu, 13 Aug 2015 01:31:49 -0400 Subject: [PATCH 12/12] add draft --- singleton/presentation/index.html | 57 +++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) create mode 100644 singleton/presentation/index.html diff --git a/singleton/presentation/index.html b/singleton/presentation/index.html new file mode 100644 index 000000000..238bdb50f --- /dev/null +++ b/singleton/presentation/index.html @@ -0,0 +1,57 @@ + + + + + Circular Slides - impress.js + + + +
+
My Slides +
+
Slide 1
+
Slide 2
+
Slide 3
+
Slide 4
+ +
+
+ + +