bbottema / generic-object-pool Goto Github PK

default <U> Pool<U, X> map(Function<? super X, U> mapper);

@Value.Immutable
@Value.Style(stagedBuilder = true)
public interface Pool<T, X> {

	GenericObjectPool<X> getGenericObjectPool();

	Function<? super X, T> getMapper();

	default <U> Pool<U, X> map(Function<? super X, U> mapper) {
		return ImmutablePool.<U, X>builder().genericObjectPool(getGenericObjectPool()).mapper(mapper).build();
	}

	/**
	 * @param timeout
	 * @return
	 * @throws InterruptedException
	 * @throws IllegalStateException
	 * @see org.bbottema.genericobjectpool.GenericObjectPool#claim(org.bbottema.genericobjectpool.util.Timeout)
	 */
	@SuppressWarnings("resource")
	@Nullable
	default Poolo<T> claim(Timeout timeout) throws InterruptedException, IllegalStateException {
		var po = getGenericObjectPool().claim(timeout);
		if (po == null)
			return null;
		var poolo = new Poolo<X>() {

			@Override
			public PoolableObject<?> getPoolableObject() {
				return po;
			}

			@Override
			public X getAllocatedObject() {
				return po.getAllocatedObject();
			}
		};
		return poolo.map(getMapper());
	}

	public static <X> ImmutablePool<X, X> build(GenericObjectPool<X> genericObjectPool) {
		return build(genericObjectPool, Function.identity());
	}

	public static <T, X> ImmutablePool<T, X> build(GenericObjectPool<X> genericObjectPool,
			Function<? super X, T> mapper) {
		return ImmutablePool.<T, X>builder().genericObjectPool(genericObjectPool).mapper(mapper).build();
	}

	public static abstract class Abs<T, X> implements Pool<T, X> {

		private final GenericObjectPool<X> genericObjectPool;

		public Abs(GenericObjectPool<X> genericObjectPool) {
			super();
			this.genericObjectPool = Objects.requireNonNull(genericObjectPool);
		}

		@Override
		public GenericObjectPool<X> getGenericObjectPool() {
			return genericObjectPool;
		}
	}

	public static class Impl<X> extends Pool.Abs<X, X> {

		public Impl(GenericObjectPool<X> genericObjectPool) {
			super(genericObjectPool);
		}

		@Override
		public Function<? super X, X> getMapper() {
			return Function.identity();
		}

	}

	// *****************************delegates

@Value.Immutable
@Value.Style(stagedBuilder = true)
public interface Poolo<T> extends AutoCloseable {

	PoolableObject<?> getPoolableObject();

	/**
	 * @return
	 * @see org.bbottema.genericobjectpool.PoolableObject#getAllocatedObject()
	 */
	@Nullable
	T getAllocatedObject();

	@SuppressWarnings("unchecked")
	default <U> Poolo<U> map(Function<? super T, U> mapper) {
		Objects.requireNonNull(mapper);
		var allocatedObject = getAllocatedObject();
		var allocatedObjectUpdated = mapper.apply(allocatedObject);
		if (allocatedObject == allocatedObjectUpdated)
			return (Poolo<U>) this;
		return ImmutablePoolo.<U>builder()
				.poolableObject(getPoolableObject())
				.allocatedObject(allocatedObjectUpdated)
				.build();
	}

	@Override
	default void close() {
		this.getPoolableObject().release();
	}

	// **********************delegates