ratpack.registry.internal.CachingRegistry 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 2013 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.Predicate;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.collect.Lists;
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 java.util.List;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import static ratpack.util.ExceptionUtils.toException;
import static ratpack.util.ExceptionUtils.uncheck;
public class CachingRegistry implements Registry {
private final Registry delegate;
private final LoadingCache, ? extends Optional> cache = CacheBuilder.newBuilder().build(new CacheLoader, Optional>() {
public Optional load(@SuppressWarnings("NullableProblems") TypeToken key) throws Exception {
return delegate.maybeGet(key);
}
});
private final LoadingCache, List> allCache = CacheBuilder.newBuilder().build(new CacheLoader, List>() {
public List load(@SuppressWarnings("NullableProblems") TypeToken key) throws Exception {
return Lists.newArrayList(delegate.getAll(key));
}
});
private LoadingCache, List> predicateCache = CacheBuilder.newBuilder().build(new CacheLoader, List>() {
@Override
public List load(@SuppressWarnings("NullableProblems") PredicateCacheability.CacheKey key) throws Exception {
return Lists.newArrayList(getAll(key));
}
private Iterable getAll(PredicateCacheability.CacheKey key) {
return delegate.all(key.type, key.predicate);
}
});
public CachingRegistry(Registry delegate) {
this.delegate = delegate;
}
@Override
public Optional maybeGet(TypeToken type) {
try {
@SuppressWarnings("unchecked") Optional o = (Optional) cache.get(type);
return o;
} catch (ExecutionException | UncheckedExecutionException e) {
throw uncheck(toException(e.getCause()));
}
}
@Override
public List getAll(TypeToken type) {
try {
@SuppressWarnings("unchecked") List objects = (List) allCache.get(type);
return objects;
} catch (ExecutionException | UncheckedExecutionException e) {
throw uncheck(toException(e.getCause()));
}
}
private List getFromPredicateCache(TypeToken type, Predicate predicate) {
try {
@SuppressWarnings("unchecked") List objects = (List) predicateCache.get(new PredicateCacheability.CacheKey<>(type, predicate));
return objects;
} catch (ExecutionException | UncheckedExecutionException e) {
throw uncheck(toException(e.getCause()));
}
}
@Override
public Optional first(TypeToken type, Predicate predicate) {
if (PredicateCacheability.isCacheable(predicate)) {
List objects = getFromPredicateCache(type, predicate);
if (objects.isEmpty()) {
return Optional.empty();
} else {
return Optional.of(objects.get(0));
}
} else {
return delegate.first(type, predicate);
}
}
@Override
public Iterable all(TypeToken type, Predicate predicate) {
if (PredicateCacheability.isCacheable(predicate)) {
return getFromPredicateCache(type, predicate);
} else {
return delegate.all(type, predicate);
}
}
@Override
public boolean each(TypeToken type, Predicate predicate, Action action) throws Exception {
Iterable all = all(type, predicate);
boolean any = false;
for (T item : all) {
any = true;
action.execute(item);
}
return any;
}
@Override
public String toString() {
return "CachingRegistry{delegate=" + delegate + '}';
}
}