* @author Michael Vorburger.ch
*/
public class DataBrokerFailuresImpl extends ForwardingDataBroker implements DataBrokerFailures {
-
private static final Logger LOG = LoggerFactory.getLogger(DataBrokerFailuresImpl.class);
private final DataBroker delegate;
private final AtomicInteger howManyFailingCommits = new AtomicInteger();
private boolean commitAndThrowException = false;
- public DataBrokerFailuresImpl(DataBroker delegate) {
+ public DataBrokerFailuresImpl(final DataBroker delegate) {
this.delegate = delegate;
}
}
@Override
- public void failReads(ReadFailedException exception) {
+ public void failReads(final ReadFailedException exception) {
unfailReads();
readException = requireNonNull(exception, "exception == null");
}
@Override
- public void failReads(int howManyTimes, ReadFailedException exception) {
+ public void failReads(final int howManyTimes, final ReadFailedException exception) {
unfailReads();
howManyFailingReads.set(howManyTimes);
readException = requireNonNull(exception, "exception == null");
}
@Override
- public void failCommits(TransactionCommitFailedException exception) {
+ public void failCommits(final TransactionCommitFailedException exception) {
unfailCommits();
this.commitException = requireNonNull(exception, "exception == null");
}
@Override
- public void failCommits(int howManyTimes, TransactionCommitFailedException exception) {
+ public void failCommits(final int howManyTimes, final TransactionCommitFailedException exception) {
howManyFailingCommits.set(howManyTimes);
this.commitException = requireNonNull(exception, "exception == null");
}
@SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
justification = "https://github.com/spotbugs/spotbugs/issues/811")
- private FluentFuture<? extends CommitInfo> handleCommit(Supplier<FluentFuture<? extends CommitInfo>> commitMethod) {
+ private FluentFuture<? extends CommitInfo> handleCommit(
+ final Supplier<FluentFuture<? extends CommitInfo>> commitMethod) {
if (howManyFailingCommits.decrementAndGet() == -1) {
commitException = null;
}
if (commitException == null) {
return commitMethod.get();
- } else {
- if (commitAndThrowException) {
- try {
- commitMethod.get().get();
- } catch (InterruptedException | ExecutionException e) {
- LOG.warn("Exception while waiting for committed transaction", e);
- }
+ }
+
+ if (commitAndThrowException) {
+ try {
+ commitMethod.get().get();
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.warn("Exception while waiting for committed transaction", e);
}
- return FluentFuture.from(Futures.immediateFailedFuture(commitException));
}
+ return FluentFuture.from(Futures.immediateFailedFuture(commitException));
}
public <T extends DataObject> FluentFuture<Optional<T>> handleRead(
- BiFunction<LogicalDatastoreType, InstanceIdentifier<T>, FluentFuture<Optional<T>>> readMethod,
- LogicalDatastoreType store, InstanceIdentifier<T> path) {
+ final BiFunction<LogicalDatastoreType, InstanceIdentifier<T>, FluentFuture<Optional<T>>> readMethod,
+ final LogicalDatastoreType store, final InstanceIdentifier<T> path) {
if (howManyFailingReads.decrementAndGet() == -1) {
readException = null;
}
if (readException == null) {
return readMethod.apply(store, path);
- } else {
- return FluentFuture.from(Futures.immediateFailedFuture(readException));
}
+ return FluentFuture.from(Futures.immediateFailedFuture(readException));
}
@Override
public ReadWriteTransaction newReadWriteTransaction() {
return new ForwardingReadWriteTransaction(delegate.newReadWriteTransaction()) {
@Override
- public <T extends DataObject> FluentFuture<Optional<T>> read(LogicalDatastoreType store,
- InstanceIdentifier<T> path) {
+ public <T extends DataObject> FluentFuture<Optional<T>> read(final LogicalDatastoreType store,
+ final InstanceIdentifier<T> path) {
return handleRead(super::read, store, path);
}
private final AugmentableExtension augmentableExtension = new AugmentableExtension();
- private boolean useBuilderExtensions(final Object bean) {
- return bean instanceof DataObject;
- }
-
@Override
public String getExpression(final Object bean) {
final String beanText = super.getExpression(bean);
if (useBuilderExtensions(bean)) {
return new StringBuilder("import static extension ").append(XtendBuilderExtensions.class.getName())
.append(".operator_doubleGreaterThan\n\n").append(beanText).toString();
- } else {
- return beanText;
}
+ return beanText;
}
@Override
protected boolean isUsingBuilder(final Object bean, final Class<?> builderClass) {
- if (useBuilderExtensions(bean)) {
- return false;
- } else {
- return super.isUsingBuilder(bean, builderClass);
- }
+ return useBuilderExtensions(bean) ? false : super.isUsingBuilder(bean, builderClass);
}
@Override
protected String getOperator(final Object bean, final Class<?> builderClass) {
- if (useBuilderExtensions(bean)) {
- return ">>";
- } else {
- return super.getOperator(bean, builderClass);
- }
+ return useBuilderExtensions(bean) ? ">>" : super.getOperator(bean, builderClass);
}
@Override
DataContainer dataContainerBean = (DataContainer) bean;
Optional<Class<?>> optBuilderClass = getOptionalBuilderClassByAppendingBuilderToClassName(
dataContainerBean.implementedInterface());
- if (optBuilderClass.isPresent()) {
- return super.getNewBeanExpression(dataContainerBean, optBuilderClass.get());
- } else {
+ if (optBuilderClass.isEmpty()) {
throw new IllegalArgumentException("DataContainer has no *Builder class: " + bean.getClass());
}
- } else {
- return super.getNewBeanExpression(bean);
+ return super.getNewBeanExpression(dataContainerBean, optBuilderClass.get());
}
+ return super.getNewBeanExpression(bean);
}
@Override
// We sort the augmentations by Class type, because the Map has unpredictable order:
.sorted(Comparator.comparing(e2 -> e2.getKey().getName()))
.forEachOrdered(e -> {
- sb.append("addAugmentation(");
- sb.append(stringify(e.getKey()));
- sb.append(", ");
- sb.append(getNewBeanExpression(e.getValue()));
- sb.append(")");
+ sb.append("addAugmentation(").append(stringify(e.getKey())).append(", ")
+ .append(getNewBeanExpression(e.getValue())).append(')');
});
return sb;
- } else {
- return "";
}
+ return "";
}
/*
}
*/
+ private static boolean useBuilderExtensions(final Object bean) {
+ return bean instanceof DataObject;
+ }
}
Top actualTop = readTx.read(OPERATIONAL, id).get().get();
AssertBeans.assertEqualByText("#{\n}", augmentableExtension.getAugmentations(actualTop));
- TopLevelList topLevelList = actualTop.getTopLevelList().values().iterator().next();
+ TopLevelList topLevelList = actualTop.nonnullTopLevelList().values().iterator().next();
AssertDataObjects.assertEqualByText("#{\n"
+ " TreeComplexUsesAugment -> new TreeComplexUsesAugmentBuilder >> [\n"
+ " containerWithUses = new ContainerWithUsesBuilder >> [\n"
+ "}", augmentableExtension.getAugmentations(topLevelList));
}
- <T extends DataObject> void put(WriteTransaction tx, LogicalDatastoreType store,
- Map.Entry<InstanceIdentifier<T>, T> obj) {
+ <T extends DataObject> void put(final WriteTransaction tx, final LogicalDatastoreType store,
+ final Map.Entry<InstanceIdentifier<T>, T> obj) {
tx.put(OPERATIONAL, obj.getKey(), obj.getValue());
}
import com.google.common.collect.Maps;
import java.util.Collections;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TreeComplexUsesAugment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TreeComplexUsesAugmentBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.complex.from.grouping.ContainerWithUses;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.complex.from.grouping.ContainerWithUsesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.Top;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.TopBuilder;
}
public static TopLevelList topLevelList() {
- TopLevelListBuilder it = new TopLevelListBuilder();
- TopLevelListKey topLevelListKey = new TopLevelListKey("foo");
- it.withKey(topLevelListKey);
- it.setName("foo");
- TreeComplexUsesAugmentBuilder treeComplexUsesAugmentBuilder = new TreeComplexUsesAugmentBuilder();
- ContainerWithUsesBuilder containerWithUsesBuilder = new ContainerWithUsesBuilder();
- containerWithUsesBuilder.setLeafFromGrouping("foo");
- ContainerWithUses containerWithUses = containerWithUsesBuilder.build();
- treeComplexUsesAugmentBuilder.setContainerWithUses(containerWithUses);
- TreeComplexUsesAugment treeComplexUsesAugment = treeComplexUsesAugmentBuilder.build();
- it.addAugmentation(TreeComplexUsesAugment.class, treeComplexUsesAugment);
- return it.build();
+ return new TopLevelListBuilder()
+ .withKey(new TopLevelListKey("foo"))
+ .setName("foo")
+ .addAugmentation(new TreeComplexUsesAugmentBuilder()
+ .setContainerWithUses(new ContainerWithUsesBuilder().setLeafFromGrouping("foo").build())
+ .build())
+ .build();
}
public static Top top() {
return new TopBuilder()
.setTopLevelList(Maps.uniqueIndex(Collections.singletonList(new TopLevelListBuilder()
.setName("foo")
- .addAugmentation(TreeComplexUsesAugment.class, new TreeComplexUsesAugmentBuilder()
+ .addAugmentation(new TreeComplexUsesAugmentBuilder()
.setContainerWithUses(new ContainerWithUsesBuilder().setLeafFromGrouping("foo").build())
.build())
.build()), TopLevelList::key))