001 /*
002 * Copyright (C) 2011 The Guava Authors
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016
017 package com.google.common.base;
018
019 import static com.google.common.base.Preconditions.checkNotNull;
020
021 import com.google.common.annotations.Beta;
022 import com.google.common.annotations.GwtCompatible;
023
024 import java.io.Serializable;
025 import java.util.Iterator;
026 import java.util.Set;
027
028 import javax.annotation.Nullable;
029
030 /**
031 * An immutable object that may contain a non-null reference to another object. Each
032 * instance of this type either contains a non-null reference, or contains nothing (in
033 * which case we say that the reference is "absent"); it is never said to "contain {@code
034 * null}".
035 *
036 * <p>A non-null {@code Optional<T>} reference can be used as a replacement for a nullable
037 * {@code T} reference. It allows you to represent "a {@code T} that must be present" and
038 * a "a {@code T} that might be absent" as two distinct types in your program, which can
039 * aid clarity.
040 *
041 * <p>Some uses of this class include
042 *
043 * <ul>
044 * <li>As a method return type, as an alternative to returning {@code null} to indicate
045 * that no value was available
046 * <li>To distinguish between "unknown" (for example, not present in a map) and "known to
047 * have no value" (present in the map, with value {@code Optional.absent()})
048 * <li>To wrap nullable references for storage in a collection that does not support
049 * {@code null} (though there are
050 * <a href="http://code.google.com/p/guava-libraries/wiki/LivingWithNullHostileCollections">
051 * several other approaches to this</a> that should be considered first)
052 * </ul>
053 *
054 * <p>A common alternative to using this class is to find or create a suitable
055 * <a href="http://en.wikipedia.org/wiki/Null_Object_pattern">null object</a> for the
056 * type in question.
057 *
058 * <p>This class is not intended as a direct analogue of any existing "option" or "maybe"
059 * construct from other programming environments, though it may bear some similarities.
060 *
061 * <p>See the Guava User Guide article on <a
062 * href="http://code.google.com/p/guava-libraries/wiki/UsingAndAvoidingNullExplained#Optional">
063 * using {@code Optional}</a>.
064 *
065 * @param <T> the type of instance that can be contained. {@code Optional} is naturally
066 * covariant on this type, so it is safe to cast an {@code Optional<T>} to {@code
067 * Optional<S>} for any supertype {@code S} of {@code T}.
068 * @author Kurt Alfred Kluever
069 * @author Kevin Bourrillion
070 * @since 10.0
071 */
072 @GwtCompatible(serializable = true)
073 public abstract class Optional<T> implements Serializable {
074 /**
075 * Returns an {@code Optional} instance with no contained reference.
076 */
077 @SuppressWarnings("unchecked")
078 public static <T> Optional<T> absent() {
079 return (Optional<T>) Absent.INSTANCE;
080 }
081
082 /**
083 * Returns an {@code Optional} instance containing the given non-null reference.
084 */
085 public static <T> Optional<T> of(T reference) {
086 return new Present<T>(checkNotNull(reference));
087 }
088
089 /**
090 * If {@code nullableReference} is non-null, returns an {@code Optional} instance containing that
091 * reference; otherwise returns {@link Optional#absent}.
092 */
093 public static <T> Optional<T> fromNullable(@Nullable T nullableReference) {
094 return (nullableReference == null)
095 ? Optional.<T>absent()
096 : new Present<T>(nullableReference);
097 }
098
099 Optional() {}
100
101 /**
102 * Returns {@code true} if this holder contains a (non-null) instance.
103 */
104 public abstract boolean isPresent();
105
106 /**
107 * Returns the contained instance, which must be present. If the instance might be
108 * absent, use {@link #or(Object)} or {@link #orNull} instead.
109 *
110 * @throws IllegalStateException if the instance is absent ({@link #isPresent} returns
111 * {@code false})
112 */
113 public abstract T get();
114
115 /**
116 * Returns the contained instance if it is present; {@code defaultValue} otherwise. If
117 * no default value should be required because the instance is known to be present, use
118 * {@link #get()} instead. For a default value of {@code null}, use {@link #orNull}.
119 *
120 * <p>Note about generics: The signature {@code public T or(T defaultValue)} is overly
121 * restrictive. However, the ideal signature, {@code public <S super T> S or(S)}, is not legal
122 * Java. As a result, some sensible operations involving subtypes are compile errors:
123 * <pre> {@code
124 *
125 * Optional<Integer> optionalInt = getSomeOptionalInt();
126 * Number value = optionalInt.or(0.5); // error
127 *
128 * FluentIterable<? extends Number> numbers = getSomeNumbers();
129 * Optional<? extends Number> first = numbers.first();
130 * Number value = first.or(0.5); // error}</pre>
131 *
132 * As a workaround, it is always safe to cast an {@code Optional<? extends T>} to {@code
133 * Optional<T>}. Casting either of the above example {@code Optional} instances to {@code
134 * Optional<Number>} (where {@code Number} is the desired output type) solves the problem:
135 * <pre> {@code
136 *
137 * Optional<Number> optionalInt = (Optional) getSomeOptionalInt();
138 * Number value = optionalInt.or(0.5); // fine
139 *
140 * FluentIterable<? extends Number> numbers = getSomeNumbers();
141 * Optional<Number> first = (Optional) numbers.first();
142 * Number value = first.or(0.5); // fine}</pre>
143 */
144 public abstract T or(T defaultValue);
145
146 /**
147 * Returns this {@code Optional} if it has a value present; {@code secondChoice}
148 * otherwise.
149 */
150 @Beta
151 public abstract Optional<T> or(Optional<? extends T> secondChoice);
152
153 /**
154 * Returns the contained instance if it is present; {@code supplier.get()} otherwise. If the
155 * supplier returns {@code null}, a {@link NullPointerException} is thrown.
156 *
157 * @throws NullPointerException if the supplier returns {@code null}
158 */
159 @Beta
160 public abstract T or(Supplier<? extends T> supplier);
161
162 /**
163 * Returns the contained instance if it is present; {@code null} otherwise. If the
164 * instance is known to be present, use {@link #get()} instead.
165 */
166 @Nullable
167 public abstract T orNull();
168
169 /**
170 * Returns an immutable singleton {@link Set} whose only element is the contained instance
171 * if it is present; an empty immutable {@link Set} otherwise.
172 *
173 * @since 11.0
174 */
175 public abstract Set<T> asSet();
176
177 /**
178 * If the instance is present, it is transformed with the given {@link Function}; otherwise,
179 * {@link Optional#absent} is returned. If the function returns {@code null}, a
180 * {@link NullPointerException} is thrown.
181 *
182 * @throws NullPointerException if the function returns {@code null}
183 *
184 * @since 12.0
185 */
186 @Beta
187 public abstract <V> Optional<V> transform(Function<? super T, V> function);
188
189 /**
190 * Returns {@code true} if {@code object} is an {@code Optional} instance, and either
191 * the contained references are {@linkplain Object#equals equal} to each other or both
192 * are absent. Note that {@code Optional} instances of differing parameterized types can
193 * be equal.
194 */
195 @Override
196 public abstract boolean equals(@Nullable Object object);
197
198 /**
199 * Returns a hash code for this instance.
200 */
201 @Override
202 public abstract int hashCode();
203
204 /**
205 * Returns a string representation for this instance. The form of this string
206 * representation is unspecified.
207 */
208 @Override
209 public abstract String toString();
210
211 /**
212 * Returns the value of each present instance from the supplied {@code optionals}, in order,
213 * skipping over occurrences of {@link Optional#absent}. Iterators are unmodifiable and are
214 * evaluated lazily.
215 *
216 * @since 11.0 (generics widened in 13.0)
217 */
218 @Beta
219 public static <T> Iterable<T> presentInstances(
220 final Iterable<? extends Optional<? extends T>> optionals) {
221 checkNotNull(optionals);
222 return new Iterable<T>() {
223 @Override
224 public Iterator<T> iterator() {
225 return new AbstractIterator<T>() {
226 private final Iterator<? extends Optional<? extends T>> iterator =
227 checkNotNull(optionals.iterator());
228
229 @Override
230 protected T computeNext() {
231 while (iterator.hasNext()) {
232 Optional<? extends T> optional = iterator.next();
233 if (optional.isPresent()) {
234 return optional.get();
235 }
236 }
237 return endOfData();
238 }
239 };
240 };
241 };
242 }
243
244 private static final long serialVersionUID = 0;
245 }