io.requery.async.CompletableEntityStore Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of requery Show documentation
Show all versions of requery Show documentation
A light but powerful object mapper and SQL generator for Java/Android
/*
* Copyright 2016 requery.io
*
* 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 io.requery.async;
import io.requery.BlockingEntityStore;
import io.requery.EntityStore;
import io.requery.meta.Attribute;
import io.requery.meta.QueryAttribute;
import io.requery.query.Deletion;
import io.requery.query.Expression;
import io.requery.query.Insertion;
import io.requery.query.Result;
import io.requery.query.Scalar;
import io.requery.query.Selection;
import io.requery.query.Tuple;
import io.requery.query.Update;
import io.requery.util.Objects;
import javax.annotation.ParametersAreNonnullByDefault;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.function.Supplier;
/**
* Implementation of {@link CompletionStageEntityStore} where all operations are passed through a
* {@link BlockingEntityStore} instance. All operations are supplied via the given {@link Executor}.
*
* @param entity base type. See {@link EntityStore}.
*
* @author Nikhil Purushe
*/
@ParametersAreNonnullByDefault
public class CompletableEntityStore implements CompletionStageEntityStore {
private final BlockingEntityStore delegate;
private final Executor executor;
private final boolean createdExecutor;
public CompletableEntityStore(BlockingEntityStore delegate) {
this.delegate = Objects.requireNotNull(delegate);
this.executor = Executors.newSingleThreadExecutor();
createdExecutor = true;
}
public CompletableEntityStore(BlockingEntityStore delegate, Executor executor) {
this.delegate = Objects.requireNotNull(delegate);
this.executor = Objects.requireNotNull(executor);
createdExecutor = false;
}
@Override
public CompletableFuture insert(final E entity) {
return CompletableFuture.supplyAsync(new Supplier() {
@Override
public E get() {
return delegate.insert(entity);
}
}, executor);
}
@Override
public CompletableFuture> insert(final Iterable entities) {
return CompletableFuture.supplyAsync(new Supplier>() {
@Override
public Iterable get() {
return delegate.insert(entities);
}
}, executor);
}
@Override
public CompletionStage insert(final E entity, final Class keyClass) {
return CompletableFuture.supplyAsync(new Supplier() {
@Override
public K get() {
return delegate.insert(entity, keyClass);
}
}, executor);
}
@Override
public CompletionStage> insert(final Iterable entities,
final Class keyClass) {
return CompletableFuture.supplyAsync(new Supplier>() {
@Override
public Iterable get() {
return delegate.insert(entities, keyClass);
}
}, executor);
}
@Override
public CompletableFuture update(final E entity) {
return CompletableFuture.supplyAsync(new Supplier() {
@Override
public E get() {
return delegate.update(entity);
}
}, executor);
}
@Override
public CompletableFuture> update(final Iterable entities) {
return CompletableFuture.supplyAsync(new Supplier>() {
@Override
public Iterable get() {
return delegate.update(entities);
}
}, executor);
}
@Override
public CompletionStage upsert(final E entity) {
return CompletableFuture.supplyAsync(new Supplier() {
@Override
public E get() {
return delegate.upsert(entity);
}
}, executor);
}
@Override
public CompletableFuture> upsert(final Iterable entities) {
return CompletableFuture.supplyAsync(new Supplier>() {
@Override
public Iterable get() {
return delegate.upsert(entities);
}
}, executor);
}
@Override
public CompletableFuture refresh(final E entity) {
return CompletableFuture.supplyAsync(new Supplier() {
@Override
public E get() {
return delegate.refresh(entity);
}
}, executor);
}
@Override
public CompletableFuture refresh(final E entity,
final Attribute... attributes) {
return CompletableFuture.supplyAsync(new Supplier() {
@Override
public E get() {
return delegate.refresh(entity, attributes);
}
}, executor);
}
@Override
public CompletionStage> refresh(final Iterable entities,
final Attribute... attributes) {
return CompletableFuture.supplyAsync(new Supplier>() {
@Override
public Iterable get() {
return delegate.refresh(entities, attributes);
}
}, executor);
}
@Override
public CompletableFuture refreshAll(final E entity) {
return CompletableFuture.supplyAsync(new Supplier() {
@Override
public E get() {
return delegate.refreshAll(entity);
}
}, executor);
}
@Override
public CompletableFuture delete(final E entity) {
return CompletableFuture.runAsync(new Runnable() {
@Override
public void run() {
delegate.delete(entity);
}
}, executor);
}
@Override
public CompletableFuture delete(final Iterable entities) {
return CompletableFuture.runAsync(new Runnable() {
@Override
public void run() {
delegate.delete(entities);
}
}, executor);
}
@Override
public CompletableFuture findByKey(final Class type, final K key) {
return CompletableFuture.supplyAsync(new Supplier() {
@Override
public E get() {
return delegate.findByKey(type, key);
}
}, executor);
}
@Override
public void close() {
try {
if (createdExecutor) {
ExecutorService executorService = (ExecutorService) executor;
executorService.shutdown();
}
} finally {
delegate.close();
}
}
@Override
public Selection> select(Expression... expressions) {
return delegate.select(expressions);
}
@Override
public Selection> select(Set> expressions) {
return delegate.select(expressions);
}
@Override
public Update> update() {
return delegate.update();
}
@Override
public Deletion> delete() {
return delegate.delete();
}
@Override
public Selection> select(Class type,
QueryAttribute... attributes) {
return delegate.select(type, attributes);
}
@Override
public Selection> select(
Class type, Set> attributes) {
return delegate.select(type, attributes);
}
@Override
public Insertion> insert(Class type) {
return delegate.insert(type);
}
@Override
public Update> update(Class type) {
return delegate.update(type);
}
@Override
public Deletion> delete(Class type) {
return delegate.delete(type);
}
@Override
public Selection> count(Class type) {
return delegate.count(type);
}
@Override
public Selection> count(QueryAttribute... attributes) {
return delegate.count(attributes);
}
@Override
public Result raw(String query, Object... parameters) {
return delegate.raw(query, parameters);
}
@Override
public Result raw(Class type, String query, Object... parameters) {
return delegate.raw(type, query, parameters);
}
@Override
public BlockingEntityStore toBlocking() {
return delegate;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy