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.TreeLeafOnlyAugment;
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.augment.rev140709.complex.from.grouping.ListViaUses;
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.two.level.list.TopLevelList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.TopLevelListBuilder;
.setContainerWithUses(new ContainerWithUsesBuilder()
.setLeafFromGrouping("foo")
.build())
- .setListViaUses(Collections.<ListViaUses>emptyList())
+ .setListViaUses(Collections.emptyList())
.build();
}
}
@SafeVarargs
private final BindingNormalizedNodeCachingCodec<Top> createCachingCodec(
final Class<? extends DataObject>... classes) {
- return topNode.createCachingCodec(ImmutableSet.<Class<? extends DataObject>>copyOf(classes));
+ return topNode.createCachingCodec(ImmutableSet.copyOf(classes));
}
private static void verifyListItemSame(final NormalizedNode<?, ?> firstTop, final NormalizedNode<?, ?> secondTop) {
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.TreeLeafOnlyAugment;
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.augment.rev140709.complex.from.grouping.ListViaUses;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.put.top.input.choice.list.choice.in.choice.list.ComplexViaUsesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.top.choice.list.choice.in.choice.list.ComplexViaUsesWithDifferentNameBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.Top;
.setContainerWithUses(new ContainerWithUsesBuilder()
.setLeafFromGrouping("foo")
.build())
- .setListViaUses(Collections.<ListViaUses>emptyList())
+ .setListViaUses(Collections.emptyList())
.build();
}
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.TreeLeafOnlyAugment;
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.augment.rev140709.complex.from.grouping.ListViaUses;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.top.top.level.list.choice.in.list.EmptyLeaf;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.top.top.level.list.choice.in.list.EmptyLeafBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.Top;
.setContainerWithUses(new ContainerWithUsesBuilder()
.setLeafFromGrouping("foo")
.build())
- .setListViaUses(Collections.<ListViaUses>emptyList())
+ .setListViaUses(Collections.emptyList())
.build();
}
for (Entry<Class<? extends Augmentation<Top>>, ? extends Augmentation<Top>> augment : augments.entrySet()) {
topBuilder.addAugmentation(augment.getKey(), augment.getValue());
}
- return topBuilder.setTopLevelList(Collections.<TopLevelList>emptyList()).build();
+ return topBuilder.setTopLevelList(Collections.emptyList()).build();
}
@Test
} else {
leafRefValueNode = SchemaContextUtil.findDataSchemaNode(schemaContext, parentModule, leafRefStrippedXPath);
}
- return leafRefValueNode != null ? leafRefValueNode.equals(parentNode) : false;
+ return leafRefValueNode != null && leafRefValueNode.equals(parentNode);
}
/**
private static boolean leafContainsEnumDefinition(final SchemaNode dataNode) {
if (dataNode instanceof LeafSchemaNode) {
final LeafSchemaNode leaf = (LeafSchemaNode) dataNode;
- if (CompatUtils.compatLeafType(leaf) instanceof EnumTypeDefinition) {
- return true;
- }
+ return CompatUtils.compatLeafType(leaf) instanceof EnumTypeDefinition;
}
return false;
}
private static boolean leafListContainsEnumDefinition(final SchemaNode dataNode) {
if (dataNode instanceof LeafListSchemaNode) {
final LeafListSchemaNode leafList = (LeafListSchemaNode) dataNode;
- if (leafList.getType() instanceof EnumTypeDefinition) {
- return true;
- }
+ return leafList.getType() instanceof EnumTypeDefinition;
}
return false;
}
for (Module module : modulesSortedByDependency) {
Map<Optional<Revision>, Map<String, Type>> dateTypeMap = genTypeDefsContextMap.computeIfAbsent(
module.getName(), key -> new HashMap<>());
- dateTypeMap.put(module.getRevision(), Collections.<String, Type>emptyMap());
+ dateTypeMap.put(module.getRevision(), Collections.emptyMap());
genTypeDefsContextMap.put(module.getName(), dateTypeMap);
}
doReturn(Optional.of(container)).when(context).findModule(any(QNameModule.class));
final DataSchemaNode node = mock(DataSchemaNode.class);
- doReturn(node).when(container).getDataChildByName((QName) any());
+ doReturn(node).when(container).getDataChildByName(any());
final TypeDefinition<?> typeDefinition = mock(TypeDefinition.class);
doReturn(Q_NAME).when(typeDefinition).getQName();
doReturn(ImmutableSet.of(typeDefinition)).when(container).getTypeDefinitions();
final DataNodeContainer dataNode =
mock(DataNodeContainer.class, withSettings().extraInterfaces(DataSchemaNode.class));
- doReturn(dataNode).when(container).getDataChildByName((QName) any());
+ doReturn(dataNode).when(container).getDataChildByName(any());
doReturn(ImmutableSet.of(typeDefinition)).when(dataNode).getTypeDefinitions();
assertEquals(typeDefinition, YangSchemaUtils.findTypeDefinition(context,
SchemaPath.create(false, Q_NAME, Q_NAME)));
final ChoiceSchemaNode choiceNode =
mock(ChoiceSchemaNode.class, withSettings().extraInterfaces(DataSchemaNode.class));
- doReturn(choiceNode).when(container).getDataChildByName((QName) any());
+ doReturn(choiceNode).when(container).getDataChildByName(any());
final CaseSchemaNode caseNode = mock(CaseSchemaNode.class);
- doReturn(caseNode).when(choiceNode).getCaseNodeByName((QName) any());
+ doReturn(caseNode).when(choiceNode).getCaseNodeByName(any());
doReturn(ImmutableSet.of(typeDefinition)).when(caseNode).getTypeDefinitions();
assertEquals(typeDefinition, YangSchemaUtils.findTypeDefinition(context,
SchemaPath.create(false, Q_NAME, Q_NAME, Q_NAME)));
}
this.paramNames = ImmutableList.copyOf(p);
- this.parameters = parameters.isEmpty() ? Collections.<AnnotationType.Parameter>emptyList()
- : Collections.unmodifiableList(parameters);
+ this.parameters = parameters.isEmpty() ? Collections.emptyList() : Collections.unmodifiableList(parameters);
}
@Override
}
static {
- final Builder<String, AbstractRangeGenerator<?>> b = ImmutableMap.<String, AbstractRangeGenerator<?>>builder();
+ final Builder<String, AbstractRangeGenerator<?>> b = ImmutableMap.builder();
addGenerator(b, new ByteRangeGenerator());
addGenerator(b, new ShortRangeGenerator());
addGenerator(b, new IntegerRangeGenerator());
pathArguments = Iterables.concat(basePath, pathBuilder.build());
}
- @SuppressWarnings("unchecked")
- final InstanceIdentifier<T> ret = (InstanceIdentifier<T>) InstanceIdentifier.trustedCreate(arg, pathArguments,
- hashBuilder.build(), wildcard);
- return ret;
+ return InstanceIdentifier.trustedCreate(arg, pathArguments, hashBuilder.build(), wildcard);
}
<N extends DataObject> InstanceIdentifierBuilderImpl<N> addWildNode(final PathArgument newArg) {
Preconditions.checkNotNull(javaType, "javaType cannot be null");
final String propertyName = "value";
- final GeneratedTOBuilder genTOBuilder = typedefToTransferObject(basePackageName, typedef, moduleName, context);
+ final GeneratedTOBuilderImpl genTOBuilder = typedefToTransferObject(basePackageName, typedef, moduleName,
+ context);
genTOBuilder.setRestrictions(BindingGeneratorUtil.getRestrictions(typedef));
final GeneratedPropertyBuilder genPropBuilder = genTOBuilder.addProperty(propertyName);
genPropBuilder.setReturnType(javaType);
}
addUnitsToGenTO(genTOBuilder, typedef.getUnits().orElse(null));
genTOBuilder.setTypedef(true);
- makeSerializable((GeneratedTOBuilderImpl) genTOBuilder);
+ makeSerializable(genTOBuilder);
return genTOBuilder.toInstance();
}
} else if ((retTypeCastProperties == null || retTypeCastProperties.isEmpty())) {
Preconditions.checkState(typedefType.getSuperType() != null);
- sb.append(generateCharArrayFieldForTypedef(fieldName,
- (GeneratedTransferObject) typedefType.getSuperType()));
+ sb.append(generateCharArrayFieldForTypedef(fieldName, typedefType.getSuperType()));
}
return sb.toString();
@Override
protected String generateInnerClassBody(GeneratedTransferObject innerClass) {
- final UnionRenderer unionRenderer = new UnionRenderer((GeneratedTransferObject) innerClass);
+ final UnionRenderer unionRenderer = new UnionRenderer(innerClass);
final String body = unionRenderer.generateAsInnerClass();
this.putAllToImportMap(unionRenderer.getImportMap());
return body;
@Deprecated
public final List<TreeArgument> getPath() {
if (legacyCache == null) {
- legacyCache = ImmutableList.<TreeArgument>copyOf(pathArguments);
+ legacyCache = ImmutableList.copyOf(pathArguments);
}
return legacyCache;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.mdsal.dom.api.DOMDataTreeListener;
import org.opendaylight.mdsal.dom.api.DOMDataTreeLoopException;
-import org.opendaylight.mdsal.dom.api.DOMDataTreeProducer;
import org.opendaylight.mdsal.dom.api.DOMDataTreeService;
import org.opendaylight.mdsal.dom.api.DOMDataTreeShard;
import org.opendaylight.mdsal.dom.api.DOMDataTreeShardingConflictException;
@Test(expected = IllegalArgumentException.class)
public void registerListenerWithEmptySubtrees() throws DOMDataTreeLoopException {
- treeService.registerListener(listener, Collections.<DOMDataTreeIdentifier>emptyList(), true,
- Collections.<DOMDataTreeProducer>emptyList());
+ treeService.registerListener(listener, Collections.emptyList(), true, Collections.emptyList());
}
@Test
public void registerRootListener() throws DOMDataTreeLoopException {
- treeService.registerListener(listener, SUBTREES_ROOT, true, Collections.<DOMDataTreeProducer>emptyList());
+ treeService.registerListener(listener, SUBTREES_ROOT, true, Collections.emptyList());
verify(rootShard, times(1)).registerTreeChangeListener(eq(ROOT_ID.getRootIdentifier()),
any(DOMDataTreeChangeListener.class));
}
@Test
public void registerTreeListener() throws DOMDataTreeLoopException {
- treeService.registerListener(listener, SUBTREES_TEST, true, Collections.<DOMDataTreeProducer>emptyList());
+ treeService.registerListener(listener, SUBTREES_TEST, true, Collections.emptyList());
verify(rootShard, times(1)).registerTreeChangeListener(eq(TEST_ID.getRootIdentifier()),
any(DOMDataTreeChangeListener.class));
}
@Test
public void registerAndCloseListener() throws DOMDataTreeLoopException {
final ListenerRegistration<DOMDataTreeListener> reg =
- treeService.registerListener(listener, SUBTREES_TEST, true,
- Collections.<DOMDataTreeProducer>emptyList());
+ treeService.registerListener(listener, SUBTREES_TEST, true, Collections.emptyList());
reg.close();
verify(storeListenerReg, times(1)).close();
}
public void receiveChangeEvent() throws DOMDataTreeLoopException {
final ArgumentCaptor<DOMDataTreeChangeListener> storeListener =
ArgumentCaptor.forClass(DOMDataTreeChangeListener.class);
- treeService.registerListener(listener, SUBTREES_TEST, true, Collections.<DOMDataTreeProducer>emptyList());
+ treeService.registerListener(listener, SUBTREES_TEST, true, Collections.emptyList());
verify(rootShard, times(1)).registerTreeChangeListener(eq(TEST_ID.getRootIdentifier()),
storeListener.capture());
DataTreeCandidates.fromNormalizedNode(TEST_ID.getRootIdentifier(), TEST_CONTAINER);
final Collection<DataTreeCandidate> changes = Collections.singleton(sentStoreCandidate);
- doNothing().when(listener).onDataTreeChanged(Mockito.<Collection<DataTreeCandidate>>any(), Mockito.anyMap());
+ doNothing().when(listener).onDataTreeChanged(Mockito.any(), Mockito.anyMap());
storeListener.getValue().onDataTreeChanged(changes);
final ArgumentCaptor<Collection<DataTreeCandidate>> candidateCapture = captorFor(Collection.class);
final DOMDataTreeListener listener = mock(DOMDataTreeListener.class);
final ArgumentCaptor<DOMDataTreeChangeListener> storeListener =
ArgumentCaptor.forClass(DOMDataTreeChangeListener.class);
- treeService.registerListener(listener, SUBTREES_TEST, true, Collections.<DOMDataTreeProducer>emptyList());
+ treeService.registerListener(listener, SUBTREES_TEST, true, Collections.emptyList());
verify(rootShard, times(1)).registerTreeChangeListener(eq(TEST_ID.getRootIdentifier()),
storeListener.capture());
@Test(expected = IllegalArgumentException.class)
public void createProducerWithEmptyList() {
- treeService.createProducer(Collections.<DOMDataTreeIdentifier>emptySet());
+ treeService.createProducer(Collections.emptySet());
}
@Test(expected = DOMDataTreeProducerBusyException.class)
}
private static ListenableFuture<Void> immediate(final boolean isSuccess, final Exception except) {
- return isSuccess ? Futures.<Void>immediateFuture(null) : Futures.<Void>immediateFailedFuture(except);
+ return isSuccess ? Futures.immediateFuture(null) : Futures.immediateFailedFuture(except);
}