Simplify/clarify internal interfaces and introduce optional types.
Moxie Marlinspike
11 years ago
parent
5f5ddd7c26
commit
f0c22d593f
@ -0,0 +1,87 @@
|
||||
/*
|
||||
* Copyright (C) 2011 The Guava Authors
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.whispersystems.libaxolotl.util.guava;
|
||||
|
||||
import static org.whispersystems.libaxolotl.util.guava.Preconditions.checkNotNull;
|
||||
|
||||
|
||||
|
||||
import java.util.Collections;
|
||||
import java.util.Set;
|
||||
|
||||
|
||||
/**
|
||||
* Implementation of an {@link Optional} not containing a reference.
|
||||
*/
|
||||
|
||||
final class Absent extends Optional<Object> {
|
||||
static final Absent INSTANCE = new Absent();
|
||||
|
||||
@Override public boolean isPresent() {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override public Object get() {
|
||||
throw new IllegalStateException("value is absent");
|
||||
}
|
||||
|
||||
@Override public Object or(Object defaultValue) {
|
||||
return checkNotNull(defaultValue, "use orNull() instead of or(null)");
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked") // safe covariant cast
|
||||
@Override public Optional<Object> or(Optional<?> secondChoice) {
|
||||
return (Optional) checkNotNull(secondChoice);
|
||||
}
|
||||
|
||||
@Override public Object or(Supplier<?> supplier) {
|
||||
return checkNotNull(supplier.get(),
|
||||
"use orNull() instead of a Supplier that returns null");
|
||||
}
|
||||
|
||||
@Override public Object orNull() {
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override public Set<Object> asSet() {
|
||||
return Collections.emptySet();
|
||||
}
|
||||
|
||||
@Override
|
||||
public <V> Optional<V> transform(Function<? super Object, V> function) {
|
||||
checkNotNull(function);
|
||||
return Optional.absent();
|
||||
}
|
||||
|
||||
@Override public boolean equals(Object object) {
|
||||
return object == this;
|
||||
}
|
||||
|
||||
@Override public int hashCode() {
|
||||
return 0x598df91c;
|
||||
}
|
||||
|
||||
@Override public String toString() {
|
||||
return "Optional.absent()";
|
||||
}
|
||||
|
||||
private Object readResolve() {
|
||||
return INSTANCE;
|
||||
}
|
||||
|
||||
private static final long serialVersionUID = 0;
|
||||
}
|
||||
@ -0,0 +1,61 @@
|
||||
/*
|
||||
* Copyright (C) 2007 The Guava Authors
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.whispersystems.libaxolotl.util.guava;
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Determines an output value based on an input value.
|
||||
*
|
||||
* <p>See the Guava User Guide article on <a href=
|
||||
* "http://code.google.com/p/guava-libraries/wiki/FunctionalExplained">the use of {@code
|
||||
* Function}</a>.
|
||||
*
|
||||
* @author Kevin Bourrillion
|
||||
* @since 2.0 (imported from Google Collections Library)
|
||||
*/
|
||||
|
||||
public interface Function<F, T> {
|
||||
/**
|
||||
* Returns the result of applying this function to {@code input}. This method is <i>generally
|
||||
* expected</i>, but not absolutely required, to have the following properties:
|
||||
*
|
||||
* <ul>
|
||||
* <li>Its execution does not cause any observable side effects.
|
||||
* <li>The computation is <i>consistent with equals</i>; that is, {@link Objects#equal
|
||||
* Objects.equal}{@code (a, b)} implies that {@code Objects.equal(function.apply(a),
|
||||
* function.apply(b))}.
|
||||
* </ul>
|
||||
*
|
||||
* @throws NullPointerException if {@code input} is null and this function does not accept null
|
||||
* arguments
|
||||
*/
|
||||
T apply(F input);
|
||||
|
||||
/**
|
||||
* Indicates whether another object is equal to this function.
|
||||
*
|
||||
* <p>Most implementations will have no reason to override the behavior of {@link Object#equals}.
|
||||
* However, an implementation may also choose to return {@code true} whenever {@code object} is a
|
||||
* {@link Function} that it considers <i>interchangeable</i> with this one. "Interchangeable"
|
||||
* <i>typically</i> means that {@code Objects.equal(this.apply(f), that.apply(f))} is true for all
|
||||
* {@code f} of type {@code F}. Note that a {@code false} result from this method does not imply
|
||||
* that the functions are known <i>not</i> to be interchangeable.
|
||||
*/
|
||||
@Override
|
||||
boolean equals(Object object);
|
||||
}
|
||||
@ -0,0 +1,232 @@
|
||||
/*
|
||||
* Copyright (C) 2011 The Guava Authors
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.whispersystems.libaxolotl.util.guava;
|
||||
|
||||
import static org.whispersystems.libaxolotl.util.guava.Preconditions.checkNotNull;
|
||||
|
||||
import java.io.Serializable;
|
||||
import java.util.Iterator;
|
||||
import java.util.Set;
|
||||
|
||||
|
||||
/**
|
||||
* An immutable object that may contain a non-null reference to another object. Each
|
||||
* instance of this type either contains a non-null reference, or contains nothing (in
|
||||
* which case we say that the reference is "absent"); it is never said to "contain {@code
|
||||
* null}".
|
||||
*
|
||||
* <p>A non-null {@code Optional<T>} reference can be used as a replacement for a nullable
|
||||
* {@code T} reference. It allows you to represent "a {@code T} that must be present" and
|
||||
* a "a {@code T} that might be absent" as two distinct types in your program, which can
|
||||
* aid clarity.
|
||||
*
|
||||
* <p>Some uses of this class include
|
||||
*
|
||||
* <ul>
|
||||
* <li>As a method return type, as an alternative to returning {@code null} to indicate
|
||||
* that no value was available
|
||||
* <li>To distinguish between "unknown" (for example, not present in a map) and "known to
|
||||
* have no value" (present in the map, with value {@code Optional.absent()})
|
||||
* <li>To wrap nullable references for storage in a collection that does not support
|
||||
* {@code null} (though there are
|
||||
* <a href="http://code.google.com/p/guava-libraries/wiki/LivingWithNullHostileCollections">
|
||||
* several other approaches to this</a> that should be considered first)
|
||||
* </ul>
|
||||
*
|
||||
* <p>A common alternative to using this class is to find or create a suitable
|
||||
* <a href="http://en.wikipedia.org/wiki/Null_Object_pattern">null object</a> for the
|
||||
* type in question.
|
||||
*
|
||||
* <p>This class is not intended as a direct analogue of any existing "option" or "maybe"
|
||||
* construct from other programming environments, though it may bear some similarities.
|
||||
*
|
||||
* <p>See the Guava User Guide article on <a
|
||||
* href="http://code.google.com/p/guava-libraries/wiki/UsingAndAvoidingNullExplained#Optional">
|
||||
* using {@code Optional}</a>.
|
||||
*
|
||||
* @param <T> the type of instance that can be contained. {@code Optional} is naturally
|
||||
* covariant on this type, so it is safe to cast an {@code Optional<T>} to {@code
|
||||
* Optional<S>} for any supertype {@code S} of {@code T}.
|
||||
* @author Kurt Alfred Kluever
|
||||
* @author Kevin Bourrillion
|
||||
* @since 10.0
|
||||
*/
|
||||
public abstract class Optional<T> implements Serializable {
|
||||
/**
|
||||
* Returns an {@code Optional} instance with no contained reference.
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
public static <T> Optional<T> absent() {
|
||||
return (Optional<T>) Absent.INSTANCE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns an {@code Optional} instance containing the given non-null reference.
|
||||
*/
|
||||
public static <T> Optional<T> of(T reference) {
|
||||
return new Present<T>(checkNotNull(reference));
|
||||
}
|
||||
|
||||
/**
|
||||
* If {@code nullableReference} is non-null, returns an {@code Optional} instance containing that
|
||||
* reference; otherwise returns {@link Optional#absent}.
|
||||
*/
|
||||
public static <T> Optional<T> fromNullable(T nullableReference) {
|
||||
return (nullableReference == null)
|
||||
? Optional.<T>absent()
|
||||
: new Present<T>(nullableReference);
|
||||
}
|
||||
|
||||
Optional() {}
|
||||
|
||||
/**
|
||||
* Returns {@code true} if this holder contains a (non-null) instance.
|
||||
*/
|
||||
public abstract boolean isPresent();
|
||||
|
||||
/**
|
||||
* Returns the contained instance, which must be present. If the instance might be
|
||||
* absent, use {@link #or(Object)} or {@link #orNull} instead.
|
||||
*
|
||||
* @throws IllegalStateException if the instance is absent ({@link #isPresent} returns
|
||||
* {@code false})
|
||||
*/
|
||||
public abstract T get();
|
||||
|
||||
/**
|
||||
* Returns the contained instance if it is present; {@code defaultValue} otherwise. If
|
||||
* no default value should be required because the instance is known to be present, use
|
||||
* {@link #get()} instead. For a default value of {@code null}, use {@link #orNull}.
|
||||
*
|
||||
* <p>Note about generics: The signature {@code public T or(T defaultValue)} is overly
|
||||
* restrictive. However, the ideal signature, {@code public <S super T> S or(S)}, is not legal
|
||||
* Java. As a result, some sensible operations involving subtypes are compile errors:
|
||||
* <pre> {@code
|
||||
*
|
||||
* Optional<Integer> optionalInt = getSomeOptionalInt();
|
||||
* Number value = optionalInt.or(0.5); // error
|
||||
*
|
||||
* FluentIterable<? extends Number> numbers = getSomeNumbers();
|
||||
* Optional<? extends Number> first = numbers.first();
|
||||
* Number value = first.or(0.5); // error}</pre>
|
||||
*
|
||||
* As a workaround, it is always safe to cast an {@code Optional<? extends T>} to {@code
|
||||
* Optional<T>}. Casting either of the above example {@code Optional} instances to {@code
|
||||
* Optional<Number>} (where {@code Number} is the desired output type) solves the problem:
|
||||
* <pre> {@code
|
||||
*
|
||||
* Optional<Number> optionalInt = (Optional) getSomeOptionalInt();
|
||||
* Number value = optionalInt.or(0.5); // fine
|
||||
*
|
||||
* FluentIterable<? extends Number> numbers = getSomeNumbers();
|
||||
* Optional<Number> first = (Optional) numbers.first();
|
||||
* Number value = first.or(0.5); // fine}</pre>
|
||||
*/
|
||||
public abstract T or(T defaultValue);
|
||||
|
||||
/**
|
||||
* Returns this {@code Optional} if it has a value present; {@code secondChoice}
|
||||
* otherwise.
|
||||
*/
|
||||
public abstract Optional<T> or(Optional<? extends T> secondChoice);
|
||||
|
||||
/**
|
||||
* Returns the contained instance if it is present; {@code supplier.get()} otherwise. If the
|
||||
* supplier returns {@code null}, a {@link NullPointerException} is thrown.
|
||||
*
|
||||
* @throws NullPointerException if the supplier returns {@code null}
|
||||
*/
|
||||
public abstract T or(Supplier<? extends T> supplier);
|
||||
|
||||
/**
|
||||
* Returns the contained instance if it is present; {@code null} otherwise. If the
|
||||
* instance is known to be present, use {@link #get()} instead.
|
||||
*/
|
||||
public abstract T orNull();
|
||||
|
||||
/**
|
||||
* Returns an immutable singleton {@link Set} whose only element is the contained instance
|
||||
* if it is present; an empty immutable {@link Set} otherwise.
|
||||
*
|
||||
* @since 11.0
|
||||
*/
|
||||
public abstract Set<T> asSet();
|
||||
|
||||
/**
|
||||
* If the instance is present, it is transformed with the given {@link Function}; otherwise,
|
||||
* {@link Optional#absent} is returned. If the function returns {@code null}, a
|
||||
* {@link NullPointerException} is thrown.
|
||||
*
|
||||
* @throws NullPointerException if the function returns {@code null}
|
||||
*
|
||||
* @since 12.0
|
||||
*/
|
||||
|
||||
public abstract <V> Optional<V> transform(Function<? super T, V> function);
|
||||
|
||||
/**
|
||||
* Returns {@code true} if {@code object} is an {@code Optional} instance, and either
|
||||
* the contained references are {@linkplain Object#equals equal} to each other or both
|
||||
* are absent. Note that {@code Optional} instances of differing parameterized types can
|
||||
* be equal.
|
||||
*/
|
||||
@Override public abstract boolean equals(Object object);
|
||||
|
||||
/**
|
||||
* Returns a hash code for this instance.
|
||||
*/
|
||||
@Override public abstract int hashCode();
|
||||
|
||||
/**
|
||||
* Returns a string representation for this instance. The form of this string
|
||||
* representation is unspecified.
|
||||
*/
|
||||
@Override public abstract String toString();
|
||||
|
||||
/**
|
||||
* Returns the value of each present instance from the supplied {@code optionals}, in order,
|
||||
* skipping over occurrences of {@link Optional#absent}. Iterators are unmodifiable and are
|
||||
* evaluated lazily.
|
||||
*
|
||||
* @since 11.0 (generics widened in 13.0)
|
||||
*/
|
||||
|
||||
// public static <T> Iterable<T> presentInstances(
|
||||
// final Iterable<? extends Optional<? extends T>> optionals) {
|
||||
// checkNotNull(optionals);
|
||||
// return new Iterable<T>() {
|
||||
// @Override public Iterator<T> iterator() {
|
||||
// return new AbstractIterator<T>() {
|
||||
// private final Iterator<? extends Optional<? extends T>> iterator =
|
||||
// checkNotNull(optionals.iterator());
|
||||
//
|
||||
// @Override protected T computeNext() {
|
||||
// while (iterator.hasNext()) {
|
||||
// Optional<? extends T> optional = iterator.next();
|
||||
// if (optional.isPresent()) {
|
||||
// return optional.get();
|
||||
// }
|
||||
// }
|
||||
// return endOfData();
|
||||
// }
|
||||
// };
|
||||
// };
|
||||
// };
|
||||
// }
|
||||
|
||||
private static final long serialVersionUID = 0;
|
||||
}
|
||||
@ -0,0 +1,447 @@
|
||||
/*
|
||||
* Copyright (C) 2007 The Guava Authors
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.whispersystems.libaxolotl.util.guava;
|
||||
|
||||
|
||||
import java.util.NoSuchElementException;
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Simple static methods to be called at the start of your own methods to verify
|
||||
* correct arguments and state. This allows constructs such as
|
||||
* <pre>
|
||||
* if (count <= 0) {
|
||||
* throw new IllegalArgumentException("must be positive: " + count);
|
||||
* }</pre>
|
||||
*
|
||||
* to be replaced with the more compact
|
||||
* <pre>
|
||||
* checkArgument(count > 0, "must be positive: %s", count);</pre>
|
||||
*
|
||||
* Note that the sense of the expression is inverted; with {@code Preconditions}
|
||||
* you declare what you expect to be <i>true</i>, just as you do with an
|
||||
* <a href="http://java.sun.com/j2se/1.5.0/docs/guide/language/assert.html">
|
||||
* {@code assert}</a> or a JUnit {@code assertTrue} call.
|
||||
*
|
||||
* <p><b>Warning:</b> only the {@code "%s"} specifier is recognized as a
|
||||
* placeholder in these messages, not the full range of {@link
|
||||
* String#format(String, Object[])} specifiers.
|
||||
*
|
||||
* <p>Take care not to confuse precondition checking with other similar types
|
||||
* of checks! Precondition exceptions -- including those provided here, but also
|
||||
* {@link IndexOutOfBoundsException}, {@link NoSuchElementException}, {@link
|
||||
* UnsupportedOperationException} and others -- are used to signal that the
|
||||
* <i>calling method</i> has made an error. This tells the caller that it should
|
||||
* not have invoked the method when it did, with the arguments it did, or
|
||||
* perhaps ever. Postcondition or other invariant failures should not throw
|
||||
* these types of exceptions.
|
||||
*
|
||||
* <p>See the Guava User Guide on <a href=
|
||||
* "http://code.google.com/p/guava-libraries/wiki/PreconditionsExplained">
|
||||
* using {@code Preconditions}</a>.
|
||||
*
|
||||
* @author Kevin Bourrillion
|
||||
* @since 2.0 (imported from Google Collections Library)
|
||||
*/
|
||||
|
||||
public final class Preconditions {
|
||||
private Preconditions() {}
|
||||
|
||||
/**
|
||||
* Ensures the truth of an expression involving one or more parameters to the
|
||||
* calling method.
|
||||
*
|
||||
* @param expression a boolean expression
|
||||
* @throws IllegalArgumentException if {@code expression} is false
|
||||
*/
|
||||
public static void checkArgument(boolean expression) {
|
||||
if (!expression) {
|
||||
throw new IllegalArgumentException();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Ensures the truth of an expression involving one or more parameters to the
|
||||
* calling method.
|
||||
*
|
||||
* @param expression a boolean expression
|
||||
* @param errorMessage the exception message to use if the check fails; will
|
||||
* be converted to a string using {@link String#valueOf(Object)}
|
||||
* @throws IllegalArgumentException if {@code expression} is false
|
||||
*/
|
||||
public static void checkArgument(
|
||||
boolean expression, Object errorMessage) {
|
||||
if (!expression) {
|
||||
throw new IllegalArgumentException(String.valueOf(errorMessage));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Ensures the truth of an expression involving one or more parameters to the
|
||||
* calling method.
|
||||
*
|
||||
* @param expression a boolean expression
|
||||
* @param errorMessageTemplate a template for the exception message should the
|
||||
* check fail. The message is formed by replacing each {@code %s}
|
||||
* placeholder in the template with an argument. These are matched by
|
||||
* position - the first {@code %s} gets {@code errorMessageArgs[0]}, etc.
|
||||
* Unmatched arguments will be appended to the formatted message in square
|
||||
* braces. Unmatched placeholders will be left as-is.
|
||||
* @param errorMessageArgs the arguments to be substituted into the message
|
||||
* template. Arguments are converted to strings using
|
||||
* {@link String#valueOf(Object)}.
|
||||
* @throws IllegalArgumentException if {@code expression} is false
|
||||
* @throws NullPointerException if the check fails and either {@code
|
||||
* errorMessageTemplate} or {@code errorMessageArgs} is null (don't let
|
||||
* this happen)
|
||||
*/
|
||||
public static void checkArgument(boolean expression,
|
||||
String errorMessageTemplate,
|
||||
Object... errorMessageArgs) {
|
||||
if (!expression) {
|
||||
throw new IllegalArgumentException(
|
||||
format(errorMessageTemplate, errorMessageArgs));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Ensures the truth of an expression involving the state of the calling
|
||||
* instance, but not involving any parameters to the calling method.
|
||||
*
|
||||
* @param expression a boolean expression
|
||||
* @throws IllegalStateException if {@code expression} is false
|
||||
*/
|
||||
public static void checkState(boolean expression) {
|
||||
if (!expression) {
|
||||
throw new IllegalStateException();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Ensures the truth of an expression involving the state of the calling
|
||||
* instance, but not involving any parameters to the calling method.
|
||||
*
|
||||
* @param expression a boolean expression
|
||||
* @param errorMessage the exception message to use if the check fails; will
|
||||
* be converted to a string using {@link String#valueOf(Object)}
|
||||
* @throws IllegalStateException if {@code expression} is false
|
||||
*/
|
||||
public static void checkState(
|
||||
boolean expression, Object errorMessage) {
|
||||
if (!expression) {
|
||||
throw new IllegalStateException(String.valueOf(errorMessage));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Ensures the truth of an expression involving the state of the calling
|
||||
* instance, but not involving any parameters to the calling method.
|
||||
*
|
||||
* @param expression a boolean expression
|
||||
* @param errorMessageTemplate a template for the exception message should the
|
||||
* check fail. The message is formed by replacing each {@code %s}
|
||||
* placeholder in the template with an argument. These are matched by
|
||||
* position - the first {@code %s} gets {@code errorMessageArgs[0]}, etc.
|
||||
* Unmatched arguments will be appended to the formatted message in square
|
||||
* braces. Unmatched placeholders will be left as-is.
|
||||
* @param errorMessageArgs the arguments to be substituted into the message
|
||||
* template. Arguments are converted to strings using
|
||||
* {@link String#valueOf(Object)}.
|
||||
* @throws IllegalStateException if {@code expression} is false
|
||||
* @throws NullPointerException if the check fails and either {@code
|
||||
* errorMessageTemplate} or {@code errorMessageArgs} is null (don't let
|
||||
* this happen)
|
||||
*/
|
||||
public static void checkState(boolean expression,
|
||||
String errorMessageTemplate,
|
||||
Object... errorMessageArgs) {
|
||||
if (!expression) {
|
||||
throw new IllegalStateException(
|
||||
format(errorMessageTemplate, errorMessageArgs));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Ensures that an object reference passed as a parameter to the calling
|
||||
* method is not null.
|
||||
*
|
||||
* @param reference an object reference
|
||||
* @return the non-null reference that was validated
|
||||
* @throws NullPointerException if {@code reference} is null
|
||||
*/
|
||||
public static <T> T checkNotNull(T reference) {
|
||||
if (reference == null) {
|
||||
throw new NullPointerException();
|
||||
}
|
||||
return reference;
|
||||
}
|
||||
|
||||
/**
|
||||
* Ensures that an object reference passed as a parameter to the calling
|
||||
* method is not null.
|
||||
*
|
||||
* @param reference an object reference
|
||||
* @param errorMessage the exception message to use if the check fails; will
|
||||
* be converted to a string using {@link String#valueOf(Object)}
|
||||
* @return the non-null reference that was validated
|
||||
* @throws NullPointerException if {@code reference} is null
|
||||
*/
|
||||
public static <T> T checkNotNull(T reference, Object errorMessage) {
|
||||
if (reference == null) {
|
||||
throw new NullPointerException(String.valueOf(errorMessage));
|
||||
}
|
||||
return reference;
|
||||
}
|
||||
|
||||
/**
|
||||
* Ensures that an object reference passed as a parameter to the calling
|
||||
* method is not null.
|
||||
*
|
||||
* @param reference an object reference
|
||||
* @param errorMessageTemplate a template for the exception message should the
|
||||
* check fail. The message is formed by replacing each {@code %s}
|
||||
* placeholder in the template with an argument. These are matched by
|
||||
* position - the first {@code %s} gets {@code errorMessageArgs[0]}, etc.
|
||||
* Unmatched arguments will be appended to the formatted message in square
|
||||
* braces. Unmatched placeholders will be left as-is.
|
||||
* @param errorMessageArgs the arguments to be substituted into the message
|
||||
* template. Arguments are converted to strings using
|
||||
* {@link String#valueOf(Object)}.
|
||||
* @return the non-null reference that was validated
|
||||
* @throws NullPointerException if {@code reference} is null
|
||||
*/
|
||||
public static <T> T checkNotNull(T reference,
|
||||
String errorMessageTemplate,
|
||||
Object... errorMessageArgs) {
|
||||
if (reference == null) {
|
||||
// If either of these parameters is null, the right thing happens anyway
|
||||
throw new NullPointerException(
|
||||
format(errorMessageTemplate, errorMessageArgs));
|
||||
}
|
||||
return reference;
|
||||
}
|
||||
|
||||
/*
|
||||
* All recent hotspots (as of 2009) *really* like to have the natural code
|
||||
*
|
||||
* if (guardExpression) {
|
||||
* throw new BadException(messageExpression);
|
||||
* }
|
||||
*
|
||||
* refactored so that messageExpression is moved to a separate
|
||||
* String-returning method.
|
||||
*
|
||||
* if (guardExpression) {
|
||||
* throw new BadException(badMsg(...));
|
||||
* }
|
||||
*
|
||||
* The alternative natural refactorings into void or Exception-returning
|
||||
* methods are much slower. This is a big deal - we're talking factors of
|
||||
* 2-8 in microbenchmarks, not just 10-20%. (This is a hotspot optimizer
|
||||
* bug, which should be fixed, but that's a separate, big project).
|
||||
*
|
||||
* The coding pattern above is heavily used in java.util, e.g. in ArrayList.
|
||||
* There is a RangeCheckMicroBenchmark in the JDK that was used to test this.
|
||||
*
|
||||
* But the methods in this class want to throw different exceptions,
|
||||
* depending on the args, so it appears that this pattern is not directly
|
||||
* applicable. But we can use the ridiculous, devious trick of throwing an
|
||||
* exception in the middle of the construction of another exception.
|
||||
* Hotspot is fine with that.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Ensures that {@code index} specifies a valid <i>element</i> in an array,
|
||||
* list or string of size {@code size}. An element index may range from zero,
|
||||
* inclusive, to {@code size}, exclusive.
|
||||
*
|
||||
* @param index a user-supplied index identifying an element of an array, list
|
||||
* or string
|
||||
* @param size the size of that array, list or string
|
||||
* @return the value of {@code index}
|
||||
* @throws IndexOutOfBoundsException if {@code index} is negative or is not
|
||||
* less than {@code size}
|
||||
* @throws IllegalArgumentException if {@code size} is negative
|
||||
*/
|
||||
public static int checkElementIndex(int index, int size) {
|
||||
return checkElementIndex(index, size, "index");
|
||||
}
|
||||
|
||||
/**
|
||||
* Ensures that {@code index} specifies a valid <i>element</i> in an array,
|
||||
* list or string of size {@code size}. An element index may range from zero,
|
||||
* inclusive, to {@code size}, exclusive.
|
||||
*
|
||||
* @param index a user-supplied index identifying an element of an array, list
|
||||
* or string
|
||||
* @param size the size of that array, list or string
|
||||
* @param desc the text to use to describe this index in an error message
|
||||
* @return the value of {@code index}
|
||||
* @throws IndexOutOfBoundsException if {@code index} is negative or is not
|
||||
* less than {@code size}
|
||||
* @throws IllegalArgumentException if {@code size} is negative
|
||||
*/
|
||||
public static int checkElementIndex(
|
||||
int index, int size, String desc) {
|
||||
// Carefully optimized for execution by hotspot (explanatory comment above)
|
||||
if (index < 0 || index >= size) {
|
||||
throw new IndexOutOfBoundsException(badElementIndex(index, size, desc));
|
||||
}
|
||||
return index;
|
||||
}
|
||||
|
||||
private static String badElementIndex(int index, int size, String desc) {
|
||||
if (index < 0) {
|
||||
return format("%s (%s) must not be negative", desc, index);
|
||||
} else if (size < 0) {
|
||||
throw new IllegalArgumentException("negative size: " + size);
|
||||
} else { // index >= size
|
||||
return format("%s (%s) must be less than size (%s)", desc, index, size);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Ensures that {@code index} specifies a valid <i>position</i> in an array,
|
||||
* list or string of size {@code size}. A position index may range from zero
|
||||
* to {@code size}, inclusive.
|
||||
*
|
||||
* @param index a user-supplied index identifying a position in an array, list
|
||||
* or string
|
||||
* @param size the size of that array, list or string
|
||||
* @return the value of {@code index}
|
||||
* @throws IndexOutOfBoundsException if {@code index} is negative or is
|
||||
* greater than {@code size}
|
||||
* @throws IllegalArgumentException if {@code size} is negative
|
||||
*/
|
||||
public static int checkPositionIndex(int index, int size) {
|
||||
return checkPositionIndex(index, size, "index");
|
||||
}
|
||||
|
||||
/**
|
||||
* Ensures that {@code index} specifies a valid <i>position</i> in an array,
|
||||
* list or string of size {@code size}. A position index may range from zero
|
||||
* to {@code size}, inclusive.
|
||||
*
|
||||
* @param index a user-supplied index identifying a position in an array, list
|
||||
* or string
|
||||
* @param size the size of that array, list or string
|
||||
* @param desc the text to use to describe this index in an error message
|
||||
* @return the value of {@code index}
|
||||
* @throws IndexOutOfBoundsException if {@code index} is negative or is
|
||||
* greater than {@code size}
|
||||
* @throws IllegalArgumentException if {@code size} is negative
|
||||
*/
|
||||
public static int checkPositionIndex(
|
||||
int index, int size, String desc) {
|
||||
// Carefully optimized for execution by hotspot (explanatory comment above)
|
||||
if (index < 0 || index > size) {
|
||||
throw new IndexOutOfBoundsException(badPositionIndex(index, size, desc));
|
||||
}
|
||||
return index;
|
||||
}
|
||||
|
||||
private static String badPositionIndex(int index, int size, String desc) {
|
||||
if (index < 0) {
|
||||
return format("%s (%s) must not be negative", desc, index);
|
||||
} else if (size < 0) {
|
||||
throw new IllegalArgumentException("negative size: " + size);
|
||||
} else { // index > size
|
||||
return format("%s (%s) must not be greater than size (%s)",
|
||||
desc, index, size);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Ensures that {@code start} and {@code end} specify a valid <i>positions</i>
|
||||
* in an array, list or string of size {@code size}, and are in order. A
|
||||
* position index may range from zero to {@code size}, inclusive.
|
||||
*
|
||||
* @param start a user-supplied index identifying a starting position in an
|
||||
* array, list or string
|
||||
* @param end a user-supplied index identifying a ending position in an array,
|
||||
* list or string
|
||||
* @param size the size of that array, list or string
|
||||
* @throws IndexOutOfBoundsException if either index is negative or is
|
||||
* greater than {@code size}, or if {@code end} is less than {@code start}
|
||||
* @throws IllegalArgumentException if {@code size} is negative
|
||||
*/
|
||||
public static void checkPositionIndexes(int start, int end, int size) {
|
||||
// Carefully optimized for execution by hotspot (explanatory comment above)
|
||||
if (start < 0 || end < start || end > size) {
|
||||
throw new IndexOutOfBoundsException(badPositionIndexes(start, end, size));
|
||||
}
|
||||
}
|
||||
|
||||
private static String badPositionIndexes(int start, int end, int size) {
|
||||
if (start < 0 || start > size) {
|
||||
return badPositionIndex(start, size, "start index");
|
||||
}
|
||||
if (end < 0 || end > size) {
|
||||
return badPositionIndex(end, size, "end index");
|
||||
}
|
||||
// end < start
|
||||
return format("end index (%s) must not be less than start index (%s)",
|
||||
end, start);
|
||||
}
|
||||
|
||||
/**
|
||||
* Substitutes each {@code %s} in {@code template} with an argument. These
|
||||
* are matched by position - the first {@code %s} gets {@code args[0]}, etc.
|
||||
* If there are more arguments than placeholders, the unmatched arguments will
|
||||
* be appended to the end of the formatted message in square braces.
|
||||
*
|
||||
* @param template a non-null string containing 0 or more {@code %s}
|
||||
* placeholders.
|
||||
* @param args the arguments to be substituted into the message
|
||||
* template. Arguments are converted to strings using
|
||||
* {@link String#valueOf(Object)}. Arguments can be null.
|
||||
*/
|
||||
static String format(String template,
|
||||
Object... args) {
|
||||
template = String.valueOf(template); // null -> "null"
|
||||
|
||||
// start substituting the arguments into the '%s' placeholders
|
||||
StringBuilder builder = new StringBuilder(
|
||||
template.length() + 16 * args.length);
|
||||
int templateStart = 0;
|
||||
int i = 0;
|
||||
while (i < args.length) {
|
||||
int placeholderStart = template.indexOf("%s", templateStart);
|
||||
if (placeholderStart == -1) {
|
||||
break;
|
||||
}
|
||||
builder.append(template.substring(templateStart, placeholderStart));
|
||||
builder.append(args[i++]);
|
||||
templateStart = placeholderStart + 2;
|
||||
}
|
||||
builder.append(template.substring(templateStart));
|
||||
|
||||
// if we run out of placeholders, append the extra args in square braces
|
||||
if (i < args.length) {
|
||||
builder.append(" [");
|
||||
builder.append(args[i++]);
|
||||
while (i < args.length) {
|
||||
builder.append(", ");
|
||||
builder.append(args[i++]);
|
||||
}
|
||||
builder.append(']');
|
||||
}
|
||||
|
||||
return builder.toString();
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,88 @@
|
||||
/*
|
||||
* Copyright (C) 2011 The Guava Authors
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.whispersystems.libaxolotl.util.guava;
|
||||
|
||||
import static org.whispersystems.libaxolotl.util.guava.Preconditions.checkNotNull;
|
||||
|
||||
import java.util.Collections;
|
||||
import java.util.Set;
|
||||
|
||||
/**
|
||||
* Implementation of an {@link Optional} containing a reference.
|
||||
*/
|
||||
|
||||
final class Present<T> extends Optional<T> {
|
||||
private final T reference;
|
||||
|
||||
Present(T reference) {
|
||||
this.reference = reference;
|
||||
}
|
||||
|
||||
@Override public boolean isPresent() {
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override public T get() {
|
||||
return reference;
|
||||
}
|
||||
|
||||
@Override public T or(T defaultValue) {
|
||||
checkNotNull(defaultValue, "use orNull() instead of or(null)");
|
||||
return reference;
|
||||
}
|
||||
|
||||
@Override public Optional<T> or(Optional<? extends T> secondChoice) {
|
||||
checkNotNull(secondChoice);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override public T or(Supplier<? extends T> supplier) {
|
||||
checkNotNull(supplier);
|
||||
return reference;
|
||||
}
|
||||
|
||||
@Override public T orNull() {
|
||||
return reference;
|
||||
}
|
||||
|
||||
@Override public Set<T> asSet() {
|
||||
return Collections.singleton(reference);
|
||||
}
|
||||
|
||||
@Override public <V> Optional<V> transform(Function<? super T, V> function) {
|
||||
return new Present<V>(checkNotNull(function.apply(reference),
|
||||
"Transformation function cannot return null."));
|
||||
}
|
||||
|
||||
@Override public boolean equals(Object object) {
|
||||
if (object instanceof Present) {
|
||||
Present<?> other = (Present<?>) object;
|
||||
return reference.equals(other.reference);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override public int hashCode() {
|
||||
return 0x598df91c + reference.hashCode();
|
||||
}
|
||||
|
||||
@Override public String toString() {
|
||||
return "Optional.of(" + reference + ")";
|
||||
}
|
||||
|
||||
private static final long serialVersionUID = 0;
|
||||
}
|
||||
@ -0,0 +1,36 @@
|
||||
/*
|
||||
* Copyright (C) 2007 The Guava Authors
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.whispersystems.libaxolotl.util.guava;
|
||||
|
||||
|
||||
/**
|
||||
* A class that can supply objects of a single type. Semantically, this could
|
||||
* be a factory, generator, builder, closure, or something else entirely. No
|
||||
* guarantees are implied by this interface.
|
||||
*
|
||||
* @author Harry Heymann
|
||||
* @since 2.0 (imported from Google Collections Library)
|
||||
*/
|
||||
public interface Supplier<T> {
|
||||
/**
|
||||
* Retrieves an instance of the appropriate type. The returned object may or
|
||||
* may not be a new instance, depending on the implementation.
|
||||
*
|
||||
* @return an instance of the appropriate type
|
||||
*/
|
||||
T get();
|
||||
}
|
||||
Loading…
Reference in New Issue