Clover icon

sunshower-base

  1. Project Clover database Fri Apr 6 2018 03:41:27 UTC
  2. Package io.sunshower.lambda

File Option.java

 

Coverage histogram

../../../img/srcFileCovDistChart10.png
0% of files have more coverage

Code metrics

22
66
55
4
315
248
67
1.02
1.2
13.75
1.22

Classes

Class Line # Actions
Option 8 5 11
0.6842105468.4%
Option.Some 12 32 28
0.984615498.5%
Option.Some.SomeIterator 137 7 4
1.0100%
Option.None 162 22 24
1.0100%
 

Contributing tests

This file is covered by 62 tests. .

Source view

1    package io.sunshower.lambda;
2   
3    import java.io.Serializable;
4    import java.util.*;
5    import java.util.function.*;
6    import java.util.stream.*;
7   
 
8    public abstract class Option<T> implements Collection<T>, Serializable {
9   
 
10  47 toggle private Option() {}
11   
 
12    public static final class Some<T> extends Option<T> {
13    final T item;
14   
 
15  46 toggle public Some(T item) {
16  46 this.item = item;
17    }
18   
 
19  2 toggle public T get() {
20  2 return item;
21    }
22   
 
23  2 toggle @Override
24    public int size() {
25  2 return 1;
26    }
27   
 
28  1 toggle @Override
29    public boolean isEmpty() {
30  1 return false;
31    }
32   
 
33  5 toggle @Override
34    public boolean contains(Object o) {
35  5 return Objects.equals(o, item);
36    }
37   
 
38  8 toggle @Override
39    public Iterator<T> iterator() {
40  8 return new SomeIterator<>(item);
41    }
42   
 
43  2 toggle @Override
44    public Object[] toArray() {
45  2 return new Object[] {item};
46    }
47   
 
48  3 toggle @Override
49    @SuppressWarnings("unchecked")
50    public <T1> T1[] toArray(final T1[] a) {
51  3 if (a.length < 1) {
52  1 return (T1[]) Arrays.copyOf(toArray(), 1, a.getClass());
53    }
54  2 System.arraycopy(new Object[] {item}, 0, a, 0, 1);
55  2 if (a.length > 1) {
56  1 a[1] = null;
57    }
58  2 return a;
59    }
60   
 
61  2 toggle @Override
62    public boolean add(T t) {
63  2 return contains(t);
64    }
65   
 
66  3 toggle @Override
67    public boolean remove(Object o) {
68  3 return false;
69    }
70   
 
71  6 toggle @Override
72    public boolean containsAll(Collection<?> c) {
73  6 return c.size() == 1 && c.contains(item);
74    }
75   
 
76  1 toggle @Override
77    public boolean addAll(Collection<? extends T> c) {
78  1 return containsAll(c);
79    }
80   
 
81  2 toggle @Override
82    public boolean removeAll(Collection<?> c) {
83  2 return false;
84    }
85   
 
86  1 toggle @Override
87    public boolean retainAll(Collection<?> c) {
88  1 return containsAll(c);
89    }
90   
 
91  1 toggle @Override
92    public void clear() {
93  1 throw new UnsupportedOperationException(
94    "Some.clear() is not supported as Some() is immutable");
95    }
96   
 
97  5 toggle @Override
98    public boolean isSome() {
99  5 return true;
100    }
101   
 
102  1 toggle @Override
103    public boolean isNone() {
104  1 return false;
105    }
106   
 
107  1 toggle @Override
108    public Optional<T> toOptional() {
109  1 return Optional.of(item);
110    }
111   
 
112  1 toggle @Override
113    public T getOrElse(Supplier<T> t) {
114  1 return item;
115    }
116   
 
117  2 toggle @Override
118    public <U> Option<U> lift(Function<T, U> f) {
119  2 return Option.some(f.apply(item));
120    }
121   
 
122  1 toggle @Override
123    public <U> Option<U> fmap(Function<T, U> f) {
124  1 return lift(f);
125    }
126   
 
127  2 toggle public int hashCode() {
128  2 return item == null ? 0 : item.hashCode();
129    }
130   
 
131  6 toggle public boolean equals(Object o) {
132  1 if (o == this) return true;
133  1 if (o == null) return false;
134  4 return Some.class.equals(o.getClass()) && Objects.equals(item, ((Some) o).item);
135    }
136   
 
137    private static class SomeIterator<T> implements Iterator<T> {
138    private final T item;
139    private boolean advanced;
140   
 
141  8 toggle SomeIterator(T k) {
142  8 this.item = k;
143  8 this.advanced = false;
144    }
145   
 
146  14 toggle @Override
147    public boolean hasNext() {
148  14 return !advanced;
149    }
150   
 
151  9 toggle @Override
152    public T next() {
153  9 if (!advanced) {
154  8 advanced = true;
155  8 return item;
156    }
157  1 throw new NoSuchElementException("Some() contains a single element!");
158    }
159    }
160    }
161   
 
162    public static final class None<T> extends Option<T> {
163    static final Option<?> NONE = new None<>();
164   
 
165  1 toggle private None() {}
166   
 
167  1 toggle @Override
168    public T get() {
169  1 throw new NoSuchElementException("None() has nothing to get");
170    }
171   
 
172  1 toggle @Override
173    public boolean isSome() {
174  1 return false;
175    }
176   
 
177  5 toggle @Override
178    public boolean isNone() {
179  5 return true;
180    }
181   
 
182  1 toggle @Override
183    public Optional<T> toOptional() {
184  1 return Optional.empty();
185    }
186   
 
187  2 toggle @Override
188    public T getOrElse(Supplier<T> t) {
189  2 return t == null ? null : t.get();
190    }
191   
 
192  1 toggle @Override
193    public <U> Option<U> lift(Function<T, U> f) {
194  1 return none();
195    }
196   
 
197  1 toggle @Override
198    public <U> Option<U> fmap(Function<T, U> f) {
199  1 return none();
200    }
201   
 
202  1 toggle @Override
203    public int size() {
204  1 return 0;
205    }
206   
 
207  1 toggle @Override
208    public boolean isEmpty() {
209  1 return true;
210    }
211   
 
212  1 toggle @Override
213    public boolean contains(Object o) {
214  1 return false;
215    }
216   
 
217  2 toggle @Override
218    public Iterator<T> iterator() {
219  2 return Collections.<T>emptySet().iterator();
220    }
221   
 
222  1 toggle @Override
223    public Object[] toArray() {
224  1 return new Object[0];
225    }
226   
 
227  1 toggle @Override
228    public <T1> T1[] toArray(T1[] a) {
229  1 return a;
230    }
231   
 
232  1 toggle @Override
233    public boolean add(T t) {
234  1 return false;
235    }
236   
 
237  1 toggle @Override
238    public boolean remove(Object o) {
239  1 return false;
240    }
241   
 
242  1 toggle @Override
243    public boolean containsAll(Collection<?> c) {
244  1 return false;
245    }
246   
 
247  1 toggle @Override
248    public boolean addAll(Collection<? extends T> c) {
249  1 return false;
250    }
251   
 
252  1 toggle @Override
253    public boolean removeAll(Collection<?> c) {
254  1 return false;
255    }
256   
 
257  1 toggle @Override
258    public boolean retainAll(Collection<?> c) {
259  1 return false;
260    }
261   
 
262  1 toggle @Override
263    public void clear() {
264  1 throw new UnsupportedOperationException();
265    }
266   
 
267  1 toggle public boolean equals(Object o) {
268  1 return o == NONE;
269    }
270   
 
271  2 toggle public int hashCode() {
272  2 return 0;
273    }
274    }
275   
276    public abstract T get();
277   
278    public abstract boolean isSome();
279   
280    public abstract boolean isNone();
281   
282    public abstract Optional<T> toOptional();
283   
284    public abstract T getOrElse(Supplier<T> t);
285   
286    public abstract <U> Option<U> lift(Function<T, U> f);
287   
288    public abstract <U> Option<U> fmap(Function<T, U> f);
289   
 
290  18 toggle public static <T> Option<T> some(T u) {
291  18 return new Some<>(u);
292    }
293   
 
294  1 toggle @SafeVarargs
295    public static <T> Stream<T> bind(T... items) {
296  1 return (items == null || items.length == 0)
297    ? Stream.empty()
298  2 : Arrays.stream(items).flatMap(i -> i == null ? Stream.empty() : Stream.of(i));
299    }
300   
 
301  0 toggle @SafeVarargs
302    public static <T> Stream<T> stream(Optional<T>... options) {
303  0 return Arrays.stream(options)
304  0 .flatMap(opt -> opt.isPresent() ? Stream.of(opt.get()) : Stream.empty());
305    }
306   
 
307  30 toggle @SuppressWarnings("unchecked")
308    public static <T> Option<T> none() {
309  30 return (Option<T>) None.NONE;
310    }
311   
 
312  3 toggle public static <T> Option<T> of(T t) {
313  3 return t == null ? none() : some(t);
314    }
315    }