Crate(@Nonnull final RpcService rpcService, @Nullable final DataObject dataObject) {
this.rpcService = rpcService;
- this.dataObject = new ThreadLocal<Optional<DataObject>>() {
- @Override
- protected Optional<DataObject> initialValue() {
- return dataObject == null ? Optional.empty() : Optional.of(dataObject);
- }
- };
+ this.dataObject =
+ ThreadLocal.withInitial(() -> dataObject == null ? Optional.empty() : Optional.of(dataObject));
}
RpcService getRpcService() {
private static final Logger LOG = LoggerFactory.getLogger(DataObjectCodecContext.class);
private static final MethodType CONSTRUCTOR_TYPE = MethodType.methodType(void.class, InvocationHandler.class);
private static final MethodType DATAOBJECT_TYPE = MethodType.methodType(DataObject.class, InvocationHandler.class);
- private static final Comparator<Method> METHOD_BY_ALPHABET = (o1, o2) -> o1.getName().compareTo(o2.getName());
+ private static final Comparator<Method> METHOD_BY_ALPHABET = Comparator.comparing(Method::getName);
private final ImmutableMap<String, LeafNodeCodecContext<?>> leafChild;
private final ImmutableMap<YangInstanceIdentifier.PathArgument, NodeContextSupplier> byYang;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.Constructor;
import java.util.ArrayList;
-import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
final List<QName> sortedKeys;
if (unsortedKeys.size() > 1) {
final List<QName> tmp = new ArrayList<>(unsortedKeys);
- Collections.sort(tmp, (q1, q2) -> q1.getLocalName().compareToIgnoreCase(q2.getLocalName()));
+ tmp.sort((q1, q2) -> q1.getLocalName().compareToIgnoreCase(q2.getLocalName()));
sortedKeys = tmp;
} else {
sortedKeys = unsortedKeys;
* @return defining SchemaNodes, guaranteed to be non-empty
*/
public List<? extends SchemaNode> getNodes() {
- return nodes.stream().filter(node -> {
- return node instanceof EffectiveStatement && ((EffectiveStatement<?, ?>) node).getDeclared() != null;
- }).collect(Collectors.toList());
+ return nodes.stream().filter(node -> node instanceof EffectiveStatement
+ && ((EffectiveStatement<?, ?>) node).getDeclared() != null).collect(Collectors.toList());
}
}
if (module instanceof ModuleEffectiveStatement) {
final ModuleEffectiveStatement effective = (ModuleEffectiveStatement) module;
- final boolean anyDeclared = nodes.stream().anyMatch(node -> {
- return node instanceof EffectiveStatement && ((EffectiveStatement<?, ?>) node).getDeclared() != null;
- });
+ final boolean anyDeclared = nodes.stream().anyMatch(node ->
+ node instanceof EffectiveStatement && ((EffectiveStatement<?, ?>) node).getDeclared() != null);
if (anyDeclared) {
return Optional.of(new Multiple(effective, nodes));
}
private GeneratedTypeBuilder addRawAugmentGenTypeDefinition(final ModuleContext context,
final String augmentPackageName, final Type targetTypeRef,
final AugmentationSchemaNode augSchema) {
- Map<String, GeneratedTypeBuilder> augmentBuilders = genTypeBuilders.get(augmentPackageName);
- if (augmentBuilders == null) {
- augmentBuilders = new HashMap<>();
- genTypeBuilders.put(augmentPackageName, augmentBuilders);
- }
+ Map<String, GeneratedTypeBuilder> augmentBuilders =
+ genTypeBuilders.computeIfAbsent(augmentPackageName, k -> new HashMap<>());
final String augIdentifier = getAugmentIdentifier(augSchema.getUnknownSchemaNodes());
String augTypeName;
final Map<Integer, List<TypeDefinition<?>>> typeDefinitionsDepths = new TreeMap<>();
for (TypeDefinition<?> unsortedTypeDefinition : unsortedTypeDefinitions) {
final Integer depth = getTypeDefinitionDepth(unsortedTypeDefinition);
- List<TypeDefinition<?>> typeDefinitionsConcreteDepth = typeDefinitionsDepths.get(depth);
- if (typeDefinitionsConcreteDepth == null) {
- typeDefinitionsConcreteDepth = new ArrayList<>();
- typeDefinitionsDepths.put(depth, typeDefinitionsConcreteDepth);
- }
+ List<TypeDefinition<?>> typeDefinitionsConcreteDepth =
+ typeDefinitionsDepths.computeIfAbsent(depth, k -> new ArrayList<>());
typeDefinitionsConcreteDepth.add(unsortedTypeDefinition);
}
return sb.toString();
}
- private static final Comparator<Bit> BIT_NAME_COMPARATOR = (o1, o2) -> o1.getName().compareTo(o2.getName());
+ private static final Comparator<Bit> BIT_NAME_COMPARATOR = Comparator.comparing(Bit::getName);
private static String bitsToDef(final BitsTypeDefinition type, final String className, final String defaultValue, final boolean isExt) {
final List<Bit> bits = new ArrayList<>(type.getBits());
- Collections.sort(bits, BIT_NAME_COMPARATOR);
+ bits.sort(BIT_NAME_COMPARATOR);
final StringBuilder sb = new StringBuilder();
if (!isExt) {
sb.append("new ");
}
if (module == null) {
final List<Module> modulesList = new ArrayList<>(modules);
- Collections.sort(modulesList, (o1, o2) -> Revision.compare(o1.getRevision(), o2.getRevision()));
+ modulesList.sort((o1, o2) -> Revision.compare(o1.getRevision(), o2.getRevision()));
module = modulesList.get(0);
}
} else {
};
private static final Comparator<TypeMemberBuilder<?>> SUID_MEMBER_COMPARATOR =
- (o1, o2) -> o1.getName().compareTo(o2.getName());
+ Comparator.comparing(TypeMemberBuilder::getName);
- private static final Comparator<Type> SUID_NAME_COMPARATOR =
- (o1, o2) -> o1.getFullyQualifiedName().compareTo(o2.getFullyQualifiedName());
+ private static final Comparator<Type> SUID_NAME_COMPARATOR = Comparator.comparing(Type::getFullyQualifiedName);
/**
* Converts <code>parameterName</code> to valid JAVA parameter name.
private static <T> Iterable<T> sortedCollection(final Comparator<? super T> comparator, final Collection<T> input) {
if (input.size() > 1) {
final List<T> ret = new ArrayList<>(input);
- Collections.sort(ret, comparator);
+ ret.sort(comparator);
return ret;
} else {
return input;
}
}
- private static final ThreadLocal<MessageDigest> SHA1_MD = new ThreadLocal<MessageDigest>() {
- @Override
- protected MessageDigest initialValue() {
- try {
- return MessageDigest.getInstance("SHA");
- } catch (final NoSuchAlgorithmException e) {
- throw new IllegalStateException("Failed to get a SHA digest provider", e);
- }
+ private static final ThreadLocal<MessageDigest> SHA1_MD = ThreadLocal.withInitial(() -> {
+ try {
+ return MessageDigest.getInstance("SHA");
+ } catch (final NoSuchAlgorithmException e) {
+ throw new IllegalStateException("Failed to get a SHA digest provider", e);
}
- };
+ });
public static long computeDefaultSUID(final GeneratedTypeBuilderBase<?> to) {
final ByteArrayOutputStream bout = new ByteArrayOutputStream();
import java.io.IOException;
import java.net.URISyntaxException;
import java.nio.charset.StandardCharsets;
-import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.function.Supplier;
protected static final void generateTestSources(final List<Type> types, final File sourcesOutputDir)
throws IOException {
- Collections.sort(types, (o1, o2) -> o2.getName().compareTo(o1.getName()));
+ types.sort((o1, o2) -> o2.getName().compareTo(o1.getName()));
final GeneratorJavaFile generator = new GeneratorJavaFile(ImmutableSet.copyOf(types));
final Table<?, String, Supplier<String>> generatedFiles = generator.generateFileContent(true);
import ch.vorburger.xtendbeans.XtendBeanGenerator;
import com.google.common.collect.ClassToInstanceMap;
import com.google.common.collect.Iterables;
+import java.util.Comparator;
import java.util.Optional;
import org.opendaylight.yangtools.yang.binding.Augmentable;
import org.opendaylight.yangtools.yang.binding.Augmentation;
StringBuilder sb = new StringBuilder();
optional.get().entrySet().stream()
// We sort the augmentations by Class type, because the Map has unpredictable order:
- .sorted((e1, e2) -> e1.getKey().getName().compareTo(e2.getKey().getName()))
+ .sorted(Comparator.comparing(e2 -> e2.getKey().getName()))
.forEachOrdered(e -> {
sb.append("addAugmentation(");
sb.append(stringify(e.getKey()));
TreeComplexUsesAugmentBuilder treeComplexUsesAugmentBuilder = new TreeComplexUsesAugmentBuilder();
final Procedure1<TreeComplexUsesAugmentBuilder> _function_2 = (TreeComplexUsesAugmentBuilder it2) -> {
ContainerWithUsesBuilder containerWithUsesBuilder = new ContainerWithUsesBuilder();
- final Procedure1<ContainerWithUsesBuilder> _function_3 = (ContainerWithUsesBuilder it3) -> {
- it3.setLeafFromGrouping("foo");
- };
- ContainerWithUses doubleGreaterThan = XtendBuilderExtensions
- .<ContainerWithUses, ContainerWithUsesBuilder>operator_doubleGreaterThan(
+ final Procedure1<ContainerWithUsesBuilder> _function_3 =
+ (ContainerWithUsesBuilder it3) -> it3.setLeafFromGrouping("foo");
+ ContainerWithUses doubleGreaterThan = XtendBuilderExtensions.operator_doubleGreaterThan(
containerWithUsesBuilder, _function_3);
it2.setContainerWithUses(doubleGreaterThan);
};
- TreeComplexUsesAugment doubleGreaterThan = XtendBuilderExtensions
- .<TreeComplexUsesAugment, TreeComplexUsesAugmentBuilder>operator_doubleGreaterThan(
+ TreeComplexUsesAugment doubleGreaterThan = XtendBuilderExtensions.operator_doubleGreaterThan(
treeComplexUsesAugmentBuilder, _function_2);
it1.addAugmentation(TreeComplexUsesAugment.class, doubleGreaterThan);
};
- TopLevelList doubleGreaterThan = XtendBuilderExtensions
- .<TopLevelList, TopLevelListBuilder>operator_doubleGreaterThan(topLevelListBuilder, _function_1);
- it.setTopLevelList(Collections
- .<TopLevelList>unmodifiableList(CollectionLiterals.<TopLevelList>newArrayList(doubleGreaterThan)));
+ TopLevelList doubleGreaterThan =
+ XtendBuilderExtensions.operator_doubleGreaterThan(topLevelListBuilder, _function_1);
+ it.setTopLevelList(Collections.unmodifiableList(CollectionLiterals.newArrayList(doubleGreaterThan)));
};
- return XtendBuilderExtensions.<Top, TopBuilder>operator_doubleGreaterThan(topBuilder, _function);
+ return XtendBuilderExtensions.operator_doubleGreaterThan(topBuilder, _function);
}
}
import java.lang.invoke.MethodHandles;
import java.lang.reflect.Constructor;
import java.util.ArrayList;
-import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
final List<QName> sortedKeys;
if (unsortedKeys.size() > 1) {
final List<QName> tmp = new ArrayList<>(unsortedKeys);
- Collections.sort(tmp, (q1, q2) -> q1.getLocalName().compareToIgnoreCase(q2.getLocalName()));
+ tmp.sort((q1, q2) -> q1.getLocalName().compareToIgnoreCase(q2.getLocalName()));
sortedKeys = tmp;
} else {
sortedKeys = unsortedKeys;
}
};
- private static final Callable<? extends SchemaUnawareCodec> EMPTY_LOADER = new Callable<SchemaUnawareCodec>() {
-
- @Override
- public SchemaUnawareCodec call() {
- return EMPTY_CODEC;
- }
- };
-
public static SchemaUnawareCodec getCodecFor(final Class<?> typeClz, final TypeDefinition<?> def) {
if (BindingReflections.isBindingClass(typeClz)) {
return getCachedSchemaUnawareCodec(typeClz, getCodecLoader(typeClz, def));
* @return defining SchemaNodes, guaranteed to be non-empty
*/
public List<? extends SchemaNode> getNodes() {
- return nodes.stream().filter(node -> {
- return node instanceof EffectiveStatement && ((EffectiveStatement<?, ?>) node).getDeclared() != null;
- }).collect(Collectors.toList());
+ return nodes.stream().filter(node -> node instanceof EffectiveStatement
+ && ((EffectiveStatement<?, ?>) node).getDeclared() != null).collect(Collectors.toList());
}
}
if (module instanceof ModuleEffectiveStatement) {
final ModuleEffectiveStatement effective = (ModuleEffectiveStatement) module;
- final boolean anyDeclared = nodes.stream().anyMatch(node -> {
- return node instanceof EffectiveStatement && ((EffectiveStatement<?, ?>) node).getDeclared() != null;
- });
+ final boolean anyDeclared = nodes.stream().anyMatch(node ->
+ node instanceof EffectiveStatement && ((EffectiveStatement<?, ?>) node).getDeclared() != null);
if (anyDeclared) {
return Optional.of(new Multiple(effective, nodes));
}
import com.google.common.base.Preconditions;
import java.util.ArrayList;
import java.util.Collection;
-import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider;
import org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil;
import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedType;
-import org.opendaylight.mdsal.binding.javav2.model.api.Type;
import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTypeBuilder;
import org.opendaylight.mdsal.binding.javav2.spec.runtime.BindingNamespaceType;
import org.opendaylight.mdsal.binding.javav2.util.BindingMapping;
import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
List<Map.Entry<SchemaPath, List<AugmentationSchemaNode>>> sortedAugmentationsGrouped =
new ArrayList<>(augmentationsGrouped.entrySet());
- Collections.sort(sortedAugmentationsGrouped, AUGMENTS_COMP);
+ sortedAugmentationsGrouped.sort(AUGMENTS_COMP);
//process child nodes of grouped augment entries
for (Map.Entry<SchemaPath, List<AugmentationSchemaNode>> schemaPathAugmentListEntry : sortedAugmentationsGrouped) {
import java.util.Collection;
import java.util.List;
import java.util.Map;
+import java.util.Objects;
import java.util.Set;
import org.opendaylight.mdsal.binding.javav2.generator.context.ModuleContext;
import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider;
final List<TypeDefinition<?>> typeDefinitions = it.allTypedefs();
Preconditions.checkState(typeDefinitions != null, "Type Definitions for module «module.name» cannot be NULL.");
- typeDefinitions.stream().filter(typedef -> typedef != null).forEach(typedef -> {
+ typeDefinitions.stream().filter(Objects::nonNull).forEach(typedef -> {
final Type type = ((TypeProviderImpl) typeProvider).generatedTypeForExtendedDefinitionType(typedef,
typedef);
if (type != null) {
import java.util.Iterator;
import java.util.List;
import java.util.Map;
+import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.regex.Matcher;
genTypeDefsContextMap.put(module.getName(), dateTypeMap);
}
- modulesSortedByDependency.stream().filter(module -> module != null).forEach(module -> {
+ modulesSortedByDependency.stream().filter(Objects::nonNull).forEach(module -> {
ModuleContext context = new ModuleContext();
final String basePackageName = packageNameWithNamespacePrefix(getRootPackageName(module),
BindingNamespaceType.Typedef);
}
}
- private static final ThreadLocal<MessageDigest> SHA1_MD = new ThreadLocal<MessageDigest>() {
- @Override
- protected MessageDigest initialValue() {
- try {
- return MessageDigest.getInstance("SHA");
- } catch (final NoSuchAlgorithmException e) {
- throw new IllegalStateException("Failed to get a SHA digest provider", e);
- }
+ private static final ThreadLocal<MessageDigest> SHA1_MD = ThreadLocal.withInitial(() -> {
+ try {
+ return MessageDigest.getInstance("SHA");
+ } catch (final NoSuchAlgorithmException e) {
+ throw new IllegalStateException("Failed to get a SHA digest provider", e);
}
- };
+ });
private static String generateNormalizedPackageName(final String base, final Iterable<QName> path, final int
size, final BindingNamespaceType namespaceType) {
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Objects;
import java.util.Optional;
import java.util.stream.Collectors;
import org.opendaylight.mdsal.binding.javav2.generator.util.AbstractBaseType;
private static List<GeneratedType> toUnmodifiableEnclosedTypes(final List<GeneratedTypeBuilder> enclosedGenTypeBuilders,
final List<GeneratedTOBuilder> enclosedGenTOBuilders) {
final ArrayList<GeneratedType> enclosedTypesList = new ArrayList<>(enclosedGenTypeBuilders.size() + enclosedGenTOBuilders.size());
- enclosedTypesList.addAll(enclosedGenTypeBuilders.stream().filter(builder -> builder != null).map(GeneratedTypeBuilder::toInstance).collect(Collectors.toList()));
+ enclosedTypesList.addAll(enclosedGenTypeBuilders.stream().filter(Objects::nonNull).map(GeneratedTypeBuilder::toInstance).collect(Collectors.toList()));
- enclosedTypesList.addAll(enclosedGenTOBuilders.stream().filter(builder -> builder != null).map(GeneratedTOBuilder::toInstance).collect(Collectors.toList()));
+ enclosedTypesList.addAll(enclosedGenTOBuilders.stream().filter(Objects::nonNull).map(GeneratedTOBuilder::toInstance).collect(Collectors.toList()));
return makeUnmodifiable(enclosedTypesList);
}
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
@Beta
public class EnumerationBuilderImpl extends AbstractBaseType implements EnumBuilder {
@Override
public void updateEnumPairsFromEnumTypeDef(final EnumTypeDefinition enumTypeDef) {
- final List<EnumPair> enums = enumTypeDef.getValues();
- if (enums != null) {
- enums.stream().filter(enumPair -> enumPair != null).forEach(enumPair -> this.addValue(enumPair.getName(),
- enumPair.getValue(), enumPair.getDescription().orElse(null), enumPair.getReference().orElse(null),
- enumPair.getStatus()));
- }
+ enumTypeDef.getValues().stream().filter(Objects::nonNull).forEach(enumPair -> this.addValue(enumPair.getName(),
+ enumPair.getValue(), enumPair.getDescription().orElse(null), enumPair.getReference().orElse(null),
+ enumPair.getStatus()));
}
private static final class EnumPairImpl implements Enumeration.Pair {
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
-import java.util.Collections;
import java.util.Comparator;
-import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
-import java.util.Map;
import java.util.Objects;
import org.opendaylight.mdsal.binding.javav2.java.api.generator.rangeGenerators.AbstractRangeGenerator;
import org.opendaylight.mdsal.binding.javav2.java.api.generator.rangeGenerators.LengthGenerator;
final String name1 = p2.getName();
return name.compareTo(name1);
};
- Collections.sort(sorted, function);
+ sorted.sort(function);
allProperties = ImmutableList.copyOf(sorted);
if (restrictions != null && restrictions.getRangeConstraint().isPresent()) {
private static final RpcError DEADLOCK_RPCERROR =
RpcResultBuilder.newError(ErrorType.APPLICATION, "lock-denied", DEADLOCK_MESSAGE);
- public static final Supplier<Exception> DEADLOCK_EXCEPTION_SUPPLIER = new Supplier<Exception>() {
- @Override
- public Exception get() {
- return new TransactionCommitDeadlockException(DEADLOCK_MESSAGE, DEADLOCK_RPCERROR);
- }
- };
+ public static final Supplier<Exception> DEADLOCK_EXCEPTION_SUPPLIER =
+ () -> new TransactionCommitDeadlockException(DEADLOCK_MESSAGE, DEADLOCK_RPCERROR);
public TransactionCommitDeadlockException(final String message, final RpcError... errors) {
super(message, errors);
import com.google.common.collect.Maps;
import com.google.common.util.concurrent.FluentFuture;
import java.util.ArrayList;
+import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
// New implementation is at the end, this will move it to be the last among implementations
// with equal cost -- relying on sort() being stable.
- i.sort((i1, i2) -> Long.compare(i1.invocationCost(), i2.invocationCost()));
+ i.sort(Comparator.comparingLong(DOMRpcImplementation::invocationCost));
vb.put(ve.getKey(), i);
} else {
vb.put(ve);
b.add(ret);
listeners = b.build();
- listenerNotifier.execute(() -> ret.initialTable());
+ listenerNotifier.execute(ret::initialTable);
return ret;
}
}
@SuppressWarnings("checkstyle:IllegalCatch")
AtomicReference<Throwable> submitTxAsync(final DOMDataTreeWriteTransaction writeTx) {
final AtomicReference<Throwable> caughtEx = new AtomicReference<>();
- new Thread() {
- @Override
- public void run() {
-
- try {
- writeTx.commit();
- } catch (final Throwable e) {
- caughtEx.set(e);
- }
+ new Thread(() -> {
+ try {
+ writeTx.commit();
+ } catch (final Throwable e) {
+ caughtEx.set(e);
}
-
- }.start();
+ }).start();
return caughtEx;
}
implements DOMStoreTreeChangePublisher {
private static final Logger LOG = LoggerFactory.getLogger(AbstractDOMStoreTreeChangePublisher.class);
- private static final Supplier<List<DataTreeCandidate>> LIST_SUPPLIER = () -> new ArrayList<>();
+ private static final Supplier<List<DataTreeCandidate>> LIST_SUPPLIER = ArrayList::new;
/**
* Callback for subclass to notify a specified registration of a list of candidates. This method is guaranteed
Code Review / mdsal.git / commitdiff