ratpack.registry.internal.CachingBackedRegistry Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of ratpack-core Show documentation
Show all versions of ratpack-core Show documentation
The core HTTP and composition mechanisms of Ratpack
/*
* Copyright 2014 the original author or 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 ratpack.registry.internal;
import com.google.common.base.Objects;
import com.google.common.base.Predicate;
import com.google.common.base.Supplier;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import com.google.common.reflect.TypeToken;
import com.google.common.util.concurrent.UncheckedExecutionException;
import ratpack.func.Action;
import ratpack.registry.PredicateCacheability;
import ratpack.registry.Registry;
import ratpack.registry.RegistryBacking;
import java.util.Iterator;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import static ratpack.util.ExceptionUtils.toException;
import static ratpack.util.ExceptionUtils.uncheck;
public class CachingBackedRegistry implements Registry {
private final RegistryBacking registryBacking;
public CachingBackedRegistry(RegistryBacking registryBacking) {
this.registryBacking = registryBacking;
}
private final LoadingCache, Iterable>> supplierCache = CacheBuilder.newBuilder().build(new CacheLoader, Iterable>>() {
@Override
public Iterable> load(@SuppressWarnings("NullableProblems") TypeToken key) throws Exception {
return Objects.firstNonNull(registryBacking.provide(key), ImmutableList.>of());
}
});
private final LoadingCache, Iterable>> predicateCache = CacheBuilder.newBuilder().build(new CacheLoader, Iterable>>() {
@Override
public Iterable> load(@SuppressWarnings("NullableProblems") PredicateCacheability.CacheKey key) throws Exception {
return get(key);
}
private Iterable> get(final PredicateCacheability.CacheKey key) throws ExecutionException {
Iterable> suppliers = getSuppliers(key.type);
return FluentIterable.from(suppliers).filter(new Predicate>() {
@Override
public boolean apply(Supplier input) {
return key.predicate.apply(input.get());
}
}).toList();
}
});
public Optional maybeGet(TypeToken type) {
Iterator> suppliers = getSuppliers(type).iterator();
if (!suppliers.hasNext()) {
return Optional.empty();
} else {
return Optional.of(suppliers.next().get());
}
}
@Override
public Iterable getAll(TypeToken type) {
return transformToInstances(getSuppliers(type));
}
protected Iterable transformToInstances(Iterable> suppliers) {
//noinspection Convert2MethodRef
return Iterables.transform(suppliers, (s) -> s.get());
}
protected Iterable> getSuppliers(TypeToken type) {
try {
@SuppressWarnings("unchecked") Iterable> suppliers = (Iterable>) supplierCache.get(type);
return Objects.firstNonNull(suppliers, ImmutableList.>of());
} catch (ExecutionException | UncheckedExecutionException e) {
throw uncheck(toException(e.getCause()));
}
}
protected Iterable> getSuppliers(TypeToken type, Predicate predicate) {
try {
@SuppressWarnings("unchecked") Iterable> suppliers = (Iterable>) predicateCache.get(new PredicateCacheability.CacheKey<>(type, predicate));
return Objects.firstNonNull(suppliers, ImmutableList.>of());
} catch (ExecutionException | UncheckedExecutionException e) {
throw uncheck(toException(e.getCause()));
}
}
@Override
public Optional first(TypeToken type, Predicate predicate) {
Iterator matching = all(type, predicate).iterator();
if (!matching.hasNext()) {
return Optional.empty();
} else {
return Optional.of(matching.next());
}
}
@Override
public Iterable all(TypeToken type, Predicate predicate) {
if (PredicateCacheability.isCacheable(predicate)) {
return transformToInstances(getSuppliers(type, predicate));
} else {
return Iterables.filter(getAll(type), predicate);
}
}
@Override
public boolean each(TypeToken type, Predicate predicate, Action action) throws Exception {
if (PredicateCacheability.isCacheable(predicate)) {
Iterable all = all(type, predicate);
boolean any = false;
for (T t : all) {
any = true;
action.execute(t);
}
return any;
} else {
boolean foundMatch = false;
Iterable> suppliers = getSuppliers(type);
for (Supplier supplier : suppliers) {
T instance = supplier.get();
if (predicate.apply(instance)) {
action.execute(instance);
foundMatch = true;
}
}
return foundMatch;
}
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
CachingBackedRegistry that = (CachingBackedRegistry) o;
return registryBacking.equals(that.registryBacking);
}
@Override
public int hashCode() {
return registryBacking.hashCode();
}
}