Java Code Examples for java8.util.Optional#ofNullable()

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
  super.onCreateDialog(savedInstanceState);
  // TODO: Inject and use custom factory.
  Optional<Project> activeProject = Loadable.getValue(homeScreenViewModel.getActiveProject());
  if (!activeProject.isPresent()) {
    addFeatureRequestSubject.onError(new IllegalStateException("No active project"));
    return fail("Could not get active project");
  }
  Optional<Point> cameraPosition =
      Optional.ofNullable(mapContainerViewModel.getCameraPosition().getValue());
  if (!cameraPosition.isPresent()) {
    addFeatureRequestSubject.onError(new IllegalStateException("No camera position"));
    return fail("Could not get camera position");
  }
  return createDialog(activeProject.get(), cameraPosition.get());
}
 

@Override
public Optional<String> getTopic() {
    return Optional.ofNullable(content.getTopic());
}
 

/**
 * Returns a {@code Collector} which performs a reduction of its
 * input elements under a specified {@code BinaryOperator}.  The result
 * is described as an {@code Optional<T>}.
 *
 * <p><b>API Note:</b><br>
 * The {@code reducing()} collectors are most useful when used in a
 * multi-level reduction, downstream of {@code groupingBy} or
 * {@code partitioningBy}.  To perform a simple reduction on a stream,
 * use {@link Stream#reduce(BinaryOperator)} instead.
 *
 * <p>For example, given a stream of {@code Person}, to calculate tallest
 * person in each city:
 * <pre>{@code
 *     Comparator<Person> byHeight = Comparator.comparing(Person::getHeight);
 *     Map<City, Optional<Person>> tallestByCity
 *         = people.stream().collect(groupingBy(Person::getCity, reducing(BinaryOperator.maxBy(byHeight))));
 * }</pre>
 *
 * @param <T> element type for the input and output of the reduction
 * @param op a {@code BinaryOperator<T>} used to reduce the input elements
 * @return a {@code Collector} which implements the reduction operation
 *
 * @see #reducing(Object, BinaryOperator)
 * @see #reducing(Object, Function, BinaryOperator)
 */
public static <T> Collector<T, ?, Optional<T>>
reducing(BinaryOperator<T> op) {
    class OptionalBox implements Consumer<T> {
        T value = null;
        boolean present = false;

        @Override
        public void accept(T t) {
            if (present) {
                value = op.apply(value, t);
            }
            else {
                value = t;
                present = true;
            }
        }
    }

    return new CollectorImpl<T, OptionalBox, Optional<T>>(
            OptionalBox::new, OptionalBox::accept,
            (a, b) -> { if (b.present) a.accept(b.value); return a; },
            a -> Optional.ofNullable(a.value), CH_NOID);
}
 

@Override
public Optional<Boolean> isGuestCanJoin() {
    return Optional.ofNullable(guestCanJoin);
}
 

@Override
public Optional<Double> getUsersDefault() {
    return Optional.ofNullable(content.getUsersDefault());
}
 

@Override
public Optional<String> getTopic() {
    return Optional.ofNullable(topic);
}
 

@Override
public Optional<Boolean> isDirect() {
    return Optional.ofNullable(isDirect);
}
 

@Override
public Optional<Double> getKick() {
    return Optional.ofNullable(content.getKick());
}
 

public static Optional<JsonElement> findElement(JsonObject o, String key) {
    return Optional.ofNullable(o.get(key));
}
 

@Override
public Optional<Double> getEventsDefault() {
    return Optional.ofNullable(content.getEventsDefault());
}
 

@Override
public Optional<String> getDeviceId() {
    return Optional.ofNullable(context.getDeviceId());
}
 

public Optional<JSONObject> getJson() {
  return Optional.ofNullable(json.optJSONObject(GEOMETRY_KEY));
}
 

@Override
public Optional<String> getName() {
    return Optional.ofNullable(content.getName());
}
 

@Override
public Optional<Set<_MatrixID>> getInvites() {
    return Optional.ofNullable(invites);
}
 

@Override
public Optional<Long> getTimeout() {
    return Optional.ofNullable(timeout);
}
 

Optional<Response> getResponse(String fieldId) {
  return Optional.ofNullable(responses.get(fieldId));
}
 

public Optional<List<String>> getHeader(String name) {
    return Optional.ofNullable(headers.get(name));
}
 

public Optional<Layer> getLayer(String layerId) {
  return Optional.ofNullable(getLayerMap().get(layerId));
}
 

private Optional<String> getAsOptional(String key) {
	return Optional.ofNullable(get(key));
}
 

@Override
public Optional<Long> getLimit() {
    return Optional.ofNullable(limit);
}