001/*
002 * Copyright (C) 2011 The Guava Authors
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
005 * in compliance with the License. You may obtain a copy of the License at
006 *
007 * http://www.apache.org/licenses/LICENSE-2.0
008 *
009 * Unless required by applicable law or agreed to in writing, software distributed under the License
010 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
011 * or implied. See the License for the specific language governing permissions and limitations under
012 * the License.
013 */
014
015package com.google.common.base;
016
017import static com.google.common.base.Preconditions.checkNotNull;
018
019import com.google.common.annotations.GwtCompatible;
020import com.google.errorprone.annotations.DoNotMock;
021import java.io.Serializable;
022import java.util.Iterator;
023import java.util.Set;
024import javax.annotation.CheckForNull;
025
026/**
027 * An immutable object that may contain a non-null reference to another object. Each instance of
028 * this type either contains a non-null reference, or contains nothing (in which case we say that
029 * the reference is "absent"); it is never said to "contain {@code null}".
030 *
031 * <p>A non-null {@code Optional<T>} reference can be used as a replacement for a nullable {@code T}
032 * reference. It allows you to represent "a {@code T} that must be present" and a "a {@code T} that
033 * might be absent" as two distinct types in your program, which can aid clarity.
034 *
035 * <p>Some uses of this class include
036 *
037 * <ul>
038 *   <li>As a method return type, as an alternative to returning {@code null} to indicate that no
039 *       value was available
040 *   <li>To distinguish between "unknown" (for example, not present in a map) and "known to have no
041 *       value" (present in the map, with value {@code Optional.absent()})
042 *   <li>To wrap nullable references for storage in a collection that does not support {@code null}
043 *       (though there are <a
044 *       href="https://github.com/google/guava/wiki/LivingWithNullHostileCollections">several other
045 *       approaches to this</a> that should be considered first)
046 * </ul>
047 *
048 * <p>A common alternative to using this class is to find or create a suitable <a
049 * href="http://en.wikipedia.org/wiki/Null_Object_pattern">null object</a> for the type in question.
050 *
051 * <p>This class is not intended as a direct analogue of any existing "option" or "maybe" construct
052 * from other programming environments, though it may bear some similarities.
053 *
054 * <p>An instance of this class is serializable if its reference is absent or is a serializable
055 * object.
056 *
057 * <p><b>Comparison to {@code java.util.Optional} (JDK 8 and higher):</b> A new {@code Optional}
058 * class was added for Java 8. The two classes are extremely similar, but incompatible (they cannot
059 * share a common supertype). <i>All</i> known differences are listed either here or with the
060 * relevant methods below.
061 *
062 * <ul>
063 *   <li>This class is serializable; {@code java.util.Optional} is not.
064 *   <li>{@code java.util.Optional} has the additional methods {@code ifPresent}, {@code filter},
065 *       {@code flatMap}, and {@code orElseThrow}.
066 *   <li>{@code java.util} offers the primitive-specialized versions {@code OptionalInt}, {@code
067 *       OptionalLong} and {@code OptionalDouble}, the use of which is recommended; Guava does not
068 *       have these.
069 * </ul>
070 *
071 * <p><b>There are no plans to deprecate this class in the foreseeable future.</b> However, we do
072 * gently recommend that you prefer the new, standard Java class whenever possible.
073 *
074 * <p>See the Guava User Guide article on <a
075 * href="https://github.com/google/guava/wiki/UsingAndAvoidingNullExplained#optional">using {@code
076 * Optional}</a>.
077 *
078 * @param <T> the type of instance that can be contained. {@code Optional} is naturally covariant on
079 *     this type, so it is safe to cast an {@code Optional<T>} to {@code Optional<S>} for any
080 *     supertype {@code S} of {@code T}.
081 * @author Kurt Alfred Kluever
082 * @author Kevin Bourrillion
083 * @since 10.0
084 */
085@DoNotMock("Use Optional.of(value) or Optional.absent()")
086@GwtCompatible(serializable = true)
087@ElementTypesAreNonnullByDefault
088public abstract class Optional<T> implements Serializable {
089  /**
090   * Returns an {@code Optional} instance with no contained reference.
091   *
092   * <p><b>Comparison to {@code java.util.Optional}:</b> this method is equivalent to Java 8's
093   * {@code Optional.empty}.
094   */
095  public static <T> Optional<T> absent() {
096    return Absent.withType();
097  }
098
099  /**
100   * Returns an {@code Optional} instance containing the given non-null reference. To have {@code
101   * null} treated as {@link #absent}, use {@link #fromNullable} instead.
102   *
103   * <p><b>Comparison to {@code java.util.Optional}:</b> no differences.
104   *
105   * @throws NullPointerException if {@code reference} is null
106   */
107  public static <T> Optional<T> of(T reference) {
108    return new Present<>(checkNotNull(reference));
109  }
110
111  /**
112   * If {@code nullableReference} is non-null, returns an {@code Optional} instance containing that
113   * reference; otherwise returns {@link Optional#absent}.
114   *
115   * <p><b>Comparison to {@code java.util.Optional}:</b> this method is equivalent to Java 8's
116   * {@code Optional.ofNullable}.
117   */
118  public static <T> Optional<T> fromNullable(@CheckForNull T nullableReference) {
119    return (nullableReference == null) ? Optional.<T>absent() : new Present<T>(nullableReference);
120  }
121
122  Optional() {}
123
124  /**
125   * Returns {@code true} if this holder contains a (non-null) instance.
126   *
127   * <p><b>Comparison to {@code java.util.Optional}:</b> no differences.
128   */
129  public abstract boolean isPresent();
130
131  /**
132   * Returns the contained instance, which must be present. If the instance might be absent, use
133   * {@link #or(Object)} or {@link #orNull} instead.
134   *
135   * <p><b>Comparison to {@code java.util.Optional}:</b> when the value is absent, this method
136   * throws {@link IllegalStateException}, whereas the {@code java.util} counterpart throws {@link
137   * java.util.NoSuchElementException NoSuchElementException}.
138   *
139   * @throws IllegalStateException if the instance is absent ({@link #isPresent} returns {@code
140   *     false}); depending on this <i>specific</i> exception type (over the more general {@link
141   *     RuntimeException}) is discouraged
142   */
143  public abstract T get();
144
145  /**
146   * Returns the contained instance if it is present; {@code defaultValue} otherwise. If no default
147   * value should be required because the instance is known to be present, use {@link #get()}
148   * instead. For a default value of {@code null}, use {@link #orNull}.
149   *
150   * <p>Note about generics: The signature {@code public T or(T defaultValue)} is overly
151   * restrictive. However, the ideal signature, {@code public <S super T> S or(S)}, is not legal
152   * Java. As a result, some sensible operations involving subtypes are compile errors:
153   *
154   * <pre>{@code
155   * Optional<Integer> optionalInt = getSomeOptionalInt();
156   * Number value = optionalInt.or(0.5); // error
157   *
158   * FluentIterable<? extends Number> numbers = getSomeNumbers();
159   * Optional<? extends Number> first = numbers.first();
160   * Number value = first.or(0.5); // error
161   * }</pre>
162   *
163   * <p>As a workaround, it is always safe to cast an {@code Optional<? extends T>} to {@code
164   * Optional<T>}. Casting either of the above example {@code Optional} instances to {@code
165   * Optional<Number>} (where {@code Number} is the desired output type) solves the problem:
166   *
167   * <pre>{@code
168   * Optional<Number> optionalInt = (Optional) getSomeOptionalInt();
169   * Number value = optionalInt.or(0.5); // fine
170   *
171   * FluentIterable<? extends Number> numbers = getSomeNumbers();
172   * Optional<Number> first = (Optional) numbers.first();
173   * Number value = first.or(0.5); // fine
174   * }</pre>
175   *
176   * <p><b>Comparison to {@code java.util.Optional}:</b> this method is similar to Java 8's {@code
177   * Optional.orElse}, but will not accept {@code null} as a {@code defaultValue} ({@link #orNull}
178   * must be used instead). As a result, the value returned by this method is guaranteed non-null,
179   * which is not the case for the {@code java.util} equivalent.
180   */
181  public abstract T or(T defaultValue);
182
183  /**
184   * Returns this {@code Optional} if it has a value present; {@code secondChoice} otherwise.
185   *
186   * <p><b>Comparison to {@code java.util.Optional}:</b> this method has no equivalent in Java 8's
187   * {@code Optional} class; write {@code thisOptional.isPresent() ? thisOptional : secondChoice}
188   * instead.
189   */
190  public abstract Optional<T> or(Optional<? extends T> secondChoice);
191
192  /**
193   * Returns the contained instance if it is present; {@code supplier.get()} otherwise.
194   *
195   * <p><b>Comparison to {@code java.util.Optional}:</b> this method is similar to Java 8's {@code
196   * Optional.orElseGet}, except when {@code supplier} returns {@code null}. In this case this
197   * method throws an exception, whereas the Java 8+ method returns the {@code null} to the caller.
198   *
199   * @throws NullPointerException if this optional's value is absent and the supplier returns {@code
200   *     null}
201   */
202  public abstract T or(Supplier<? extends T> supplier);
203
204  /**
205   * Returns the contained instance if it is present; {@code null} otherwise. If the instance is
206   * known to be present, use {@link #get()} instead.
207   *
208   * <p><b>Comparison to {@code java.util.Optional}:</b> this method is equivalent to Java 8's
209   * {@code Optional.orElse(null)}.
210   */
211  @CheckForNull
212  public abstract T orNull();
213
214  /**
215   * Returns an immutable singleton {@link Set} whose only element is the contained instance if it
216   * is present; an empty immutable {@link Set} otherwise.
217   *
218   * <p><b>Comparison to {@code java.util.Optional}:</b> this method has no equivalent in Java 8's
219   * {@code Optional} class. However, this common usage:
220   *
221   * <pre>{@code
222   * for (Foo foo : possibleFoo.asSet()) {
223   *   doSomethingWith(foo);
224   * }
225   * }</pre>
226   *
227   * ... can be replaced with:
228   *
229   * <pre>{@code
230   * possibleFoo.ifPresent(foo -> doSomethingWith(foo));
231   * }</pre>
232   *
233   * <p><b>Java 9 users:</b> some use cases can be written with calls to {@code optional.stream()}.
234   *
235   * @since 11.0
236   */
237  public abstract Set<T> asSet();
238
239  /**
240   * If the instance is present, it is transformed with the given {@link Function}; otherwise,
241   * {@link Optional#absent} is returned.
242   *
243   * <p><b>Comparison to {@code java.util.Optional}:</b> this method is similar to Java 8's {@code
244   * Optional.map}, except when {@code function} returns {@code null}. In this case this method
245   * throws an exception, whereas the Java 8+ method returns {@code Optional.absent()}.
246   *
247   * @throws NullPointerException if the function returns {@code null}
248   * @since 12.0
249   */
250  public abstract <V> Optional<V> transform(Function<? super T, V> function);
251
252  /**
253   * Returns {@code true} if {@code object} is an {@code Optional} instance, and either the
254   * contained references are {@linkplain Object#equals equal} to each other or both are absent.
255   * Note that {@code Optional} instances of differing parameterized types can be equal.
256   *
257   * <p><b>Comparison to {@code java.util.Optional}:</b> no differences.
258   */
259  @Override
260  public abstract boolean equals(@CheckForNull Object object);
261
262  /**
263   * Returns a hash code for this instance.
264   *
265   * <p><b>Comparison to {@code java.util.Optional}:</b> this class leaves the specific choice of
266   * hash code unspecified, unlike the Java 8+ equivalent.
267   */
268  @Override
269  public abstract int hashCode();
270
271  /**
272   * Returns a string representation for this instance.
273   *
274   * <p><b>Comparison to {@code java.util.Optional}:</b> this class leaves the specific string
275   * representation unspecified, unlike the Java 8+ equivalent.
276   */
277  @Override
278  public abstract String toString();
279
280  /**
281   * Returns the value of each present instance from the supplied {@code optionals}, in order,
282   * skipping over occurrences of {@link Optional#absent}. Iterators are unmodifiable and are
283   * evaluated lazily.
284   *
285   * <p><b>Comparison to {@code java.util.Optional}:</b> this method has no equivalent in Java 8's
286   * {@code Optional} class; use {@code
287   * optionals.stream().filter(Optional::isPresent).map(Optional::get)} instead.
288   *
289   * <p><b>Java 9 users:</b> use {@code optionals.stream().flatMap(Optional::stream)} instead.
290   *
291   * @since 11.0 (generics widened in 13.0)
292   */
293  public static <T> Iterable<T> presentInstances(
294      final Iterable<? extends Optional<? extends T>> optionals) {
295    checkNotNull(optionals);
296    return new Iterable<T>() {
297      @Override
298      public Iterator<T> iterator() {
299        return new AbstractIterator<T>() {
300          private final Iterator<? extends Optional<? extends T>> iterator =
301              checkNotNull(optionals.iterator());
302
303          @Override
304          @CheckForNull
305          protected T computeNext() {
306            while (iterator.hasNext()) {
307              Optional<? extends T> optional = iterator.next();
308              if (optional.isPresent()) {
309                return optional.get();
310              }
311            }
312            return endOfData();
313          }
314        };
315      }
316    };
317  }
318
319  private static final long serialVersionUID = 0;
320}