All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • alexh.weak.OptionalWeak Maven / Gradle / Ivy

    package alexh.weak;

import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/** Enhanced version of an Optional, similar methods to Weak that return Optionals and don't throw */
public class OptionalWeak>  {

    private static final OptionalWeak EMPTY = new OptionalWeak(Optional.empty());

    public static > OptionalWeak of(T val) {
        return new OptionalWeak<>(Optional.ofNullable(val));
    }

    @SuppressWarnings("unchecked")
    public static > OptionalWeak empty() {
        return (OptionalWeak) EMPTY;
    }

    private final Optional inner;

    private OptionalWeak(Optional inner) {
        this.inner = inner.filter(d -> d.isPresent());
    }

    public W get() {
        return inner.get();
    }

    public boolean isPresent() {
        return inner.isPresent();
    }

    public void ifPresent(Consumer consumer) {
        inner.ifPresent(consumer);
    }

    public OptionalWeak filter(Predicate predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent()) return this;
        else return predicate.test(get()) ? this : empty();
    }

    /** @see Optional#map(Function) */
    public  Optional map(Function mapper) {
        return inner.map(mapper);
    }

    /** @see Optional#flatMap(Function) */
    public  Optional flatMap(Function> mapper) {
        return inner.flatMap(mapper);
    }

    /** @see Optional#orElse(Object) */
    public W orElse(W other) {
        return inner.orElse(other);
    }

    /** @see Optional#orElseGet(Supplier) */
    public W orElseGet(Supplier other) {
        return inner.orElseGet(other);
    }

    /** @see Optional#orElseThrow(Supplier) */
    public  W orElseThrow(Supplier exceptionSupplier) throws X {
       return inner.orElseThrow(exceptionSupplier);
    }

    /**
     * @return inner value as an optional
     */
    public Optional asObject() {
        return inner.map(d -> d.asObject());
    }

    /**
     * Returns inner value as optional of input type, if the inner value is absent or not an instance of the input
     * type an empty optional is returned
     * @param type cast type
     * @param  cast type
     * @return inner value as optional of input type
     */
    public  Optional as(Class type) {
        return inner.filter(d -> d.is(type)).map(d -> d.as(type));
    }

    /**
     * Shortcut for as(String.class)
     * @see OptionalWeak#as(Class)
     */
    public Optional asString() {
        return as(String.class);
    }

    /**
     * Shortcut for as(List.class), with malleable generic type
     * @see OptionalWeak#as(Class)
     */
    public  Optional> asList() {
        return inner.filter(d -> d.isList()).map(d -> d.asList());
    }

    /**
     * Shortcut for as(Map.class), with malleable generic type
     * @see OptionalWeak#as(Class)
     */
    public  Optional> asMap() {
        return inner.filter(d -> d.isMap()).map(d -> d.asMap());
    }

    public ConverterMaybe convert() {
        return new ConverterMaybe(inner);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        OptionalWeak that = (OptionalWeak) o;
        return Objects.equals(inner, that.inner);
    }

    @Override
    public int hashCode() {
        return Objects.hashCode(inner);
    }

    @Override
    public String toString() {
        return inner.toString();
    }
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy