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

    • com.telenav.cactus.maven.util.ThrowingOptional Maven / Gradle / Ivy

    package com.telenav.cactus.maven.util;

import com.mastfrog.function.throwing.ThrowingConsumer;
import com.mastfrog.function.throwing.ThrowingFunction;
import com.mastfrog.function.throwing.ThrowingPredicate;
import com.mastfrog.function.throwing.ThrowingRunnable;
import com.mastfrog.function.throwing.ThrowingSupplier;
import static com.mastfrog.util.preconditions.Checks.notNull;
import com.mastfrog.util.preconditions.Exceptions;
import java.util.Optional;
import java.util.function.Supplier;
import java.util.stream.Stream;

/**
 * Because optional is unusable with code that routinely does I/O or waits on
 * things, without becoming littered with try/catch blocks if you try to use
 * functional operations.
 *
 * @author Tim Boudreau
 */
public final class ThrowingOptional implements Supplier
{

    private static final ThrowingOptional EMPTY = new ThrowingOptional<>(
            Optional.empty());
    private final Optional delegate;

    ThrowingOptional(Optional delegate)
    {
        this.delegate = delegate;
    }

    public static  ThrowingOptional from(Optional delegate)
    {
        return new ThrowingOptional<>(notNull("delegate", delegate));
    }

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

    public static  ThrowingOptional of(T obj)
    {
        return new ThrowingOptional<>(Optional.of(obj));
    }

    public static  ThrowingOptional ofNullable(T obj)
    {
        return new ThrowingOptional<>(Optional.ofNullable(obj));
    }

    public Optional toOptional()
    {
        return delegate;
    }

    @Override
    public T get()
    {
        return delegate.get();
    }

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

    public boolean isEmpty()
    {
        return delegate.isEmpty();
    }

    public void ifPresent(ThrowingConsumer action)
    {
        delegate.ifPresent(action.toNonThrowing());
    }

    public void ifPresentOrElse(ThrowingConsumer action, ThrowingRunnable emptyAction)
    {
        delegate.ifPresentOrElse(action.toNonThrowing(), emptyAction.toRunnable());
    }

    public ThrowingOptional filter(ThrowingPredicate predicate)
    {
        return new ThrowingOptional<>(delegate.filter(obj ->
        {
            try
            {
                return predicate.test(obj);
            } catch (Exception | Error e)
            {
                return Exceptions.chuck(e);
            }
        }));
    }

    public  ThrowingOptional map(ThrowingFunction mapper)
    {
        return new ThrowingOptional<>(delegate.map(mapper.toNonThrowing()));
    }

    public  ThrowingOptional flatMap(ThrowingFunction> mapper)
    {
        return new ThrowingOptional<>(delegate.flatMap(mapper.toNonThrowing()));
    }

    public  ThrowingOptional flatMapThrowing(ThrowingFunction> mapper)
    {
        return new ThrowingOptional<>(delegate.flatMap(obj ->
        {
            return mapper.toNonThrowing().apply(obj).toOptional();
        }));
    }

    public ThrowingOptional or(ThrowingSupplier> supplier)
    {
        return new ThrowingOptional<>(delegate.or(() ->
        {
            try
            {
                return supplier.get();
            } catch (Exception | Error e)
            {
                return Exceptions.chuck(e);
            }
        }));
    }

    public Stream stream()
    {
        return delegate.stream();
    }

    public T orElse(T other)
    {
        return delegate.orElse(other);
    }

    public T orElseGet(ThrowingSupplier supplier)
    {
        return delegate.orElseGet(() ->
        {
            try
            {
                return supplier.get();
            } catch (Exception | Error e)
            {
                return Exceptions.chuck(e);
            }
        });
    }

    @Override
    public String toString()
    {
        if (delegate.isPresent())
        {
            return delegate.get().toString();
        }
        return "ThrowingOptional.empty()";
    }

    @Override
    public boolean equals(Object o)
    {
        if (o == this)
        {
            return true;
        } else if (o == null || o.getClass() != ThrowingOptional.class)
        {
            return false;
        }
        ThrowingOptional other = (ThrowingOptional) o;
        return other.delegate.equals(delegate);
    }

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

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy