mirror of
https://github.com/google/nomulus.git
synced 2025-05-09 16:28:21 +02:00
c6e58d3bff
The most common issues were: * Arrays.asList() shouldn't be called with a single parameter. * Broken Javadoc @links. * Unnecessary casts and type declarations. * Unnecessary unused variable initializations. ------------- Created by MOE: https://github.com/google/moe MOE_MIGRATED_REVID=230994311
88 lines
3 KiB
Java
88 lines
3 KiB
Java
// Copyright 2017 The Nomulus Authors. All Rights Reserved.
|
|
//
|
|
// 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 google.registry.model.ofy;
|
|
|
|
import static com.google.common.collect.ImmutableList.toImmutableList;
|
|
import static com.googlecode.objectify.ObjectifyService.ofy;
|
|
|
|
import com.google.common.collect.ImmutableList;
|
|
import com.google.common.collect.Streams;
|
|
import com.googlecode.objectify.Key;
|
|
import com.googlecode.objectify.Result;
|
|
import com.googlecode.objectify.cmd.DeleteType;
|
|
import com.googlecode.objectify.cmd.Deleter;
|
|
import java.util.Arrays;
|
|
import java.util.stream.Stream;
|
|
|
|
/**
|
|
* A Deleter that forwards to {@code ofy().delete()}, but can be augmented via subclassing to
|
|
* do custom processing on the keys to be deleted prior to their deletion.
|
|
*/
|
|
abstract class AugmentedDeleter implements Deleter {
|
|
private final Deleter delegate = ofy().delete();
|
|
|
|
/** Extension method to allow this Deleter to do extra work prior to the actual delete. */
|
|
protected abstract void handleDeletion(Iterable<Key<?>> keys);
|
|
|
|
private void handleDeletionStream(Stream<?> entityStream) {
|
|
handleDeletion(entityStream.map(Key::create).collect(toImmutableList()));
|
|
}
|
|
|
|
@Override
|
|
public Result<Void> entities(Iterable<?> entities) {
|
|
handleDeletionStream(Streams.stream(entities));
|
|
return delegate.entities(entities);
|
|
}
|
|
|
|
@Override
|
|
public Result<Void> entities(Object... entities) {
|
|
handleDeletionStream(Arrays.stream(entities));
|
|
return delegate.entities(entities);
|
|
}
|
|
|
|
@Override
|
|
public Result<Void> entity(Object entity) {
|
|
handleDeletionStream(Stream.of(entity));
|
|
return delegate.entity(entity);
|
|
}
|
|
|
|
@Override
|
|
public Result<Void> key(Key<?> key) {
|
|
handleDeletion(ImmutableList.of(key));
|
|
return delegate.keys(key);
|
|
}
|
|
|
|
@Override
|
|
public Result<Void> keys(Iterable<? extends Key<?>> keys) {
|
|
// Magic to convert the type Iterable<? extends Key<?>> (a family of types which allows for
|
|
// homogeneous iterables of a fixed Key<T> type, e.g. List<Key<Lock>>, and is convenient for
|
|
// callers) into the type Iterable<Key<?>> (a concrete type of heterogeneous keys, which is
|
|
// convenient for users).
|
|
handleDeletion(ImmutableList.copyOf(keys));
|
|
return delegate.keys(keys);
|
|
}
|
|
|
|
@Override
|
|
public Result<Void> keys(Key<?>... keys) {
|
|
handleDeletion(Arrays.asList(keys));
|
|
return delegate.keys(keys);
|
|
}
|
|
|
|
/** Augmenting this gets ugly; you can always just use keys(Key.create(...)) instead. */
|
|
@Override
|
|
public DeleteType type(Class<?> clazz) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
}
|