This cleans up some of the code verbosity.
Change-Id: I6d026214ad3229852984e06deb08b5a2148015f0
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
import static java.util.Objects.requireNonNull;
import com.google.common.collect.ImmutableListMultimap;
-import com.google.common.collect.ImmutableListMultimap.Builder;
import com.google.common.collect.Iterators;
import com.google.common.collect.ListMultimap;
import com.google.common.collect.Maps;
import java.util.Iterator;
-import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import javax.xml.XMLConstants;
prefixToModule = requireNonNull(module.getAll(PrefixToEffectiveModuleNamespace.class));
moduleToPrefix = requireNonNull(module.getAll(QNameModuleToPrefixNamespace.class));
- final Builder<String, String> namespaces = ImmutableListMultimap.builder();
- for (Entry<QNameModule, @NonNull String> e : moduleToPrefix.entrySet()) {
- namespaces.put(e.getKey().getNamespace().toString(), e.getValue());
+ final var namespaces = ImmutableListMultimap.<String, String>builder();
+ for (var entry : moduleToPrefix.entrySet()) {
+ namespaces.put(entry.getKey().getNamespace().toString(), entry.getValue());
}
namespaceToPrefix = namespaces.build();
}
case XMLConstants.XML_NS_PREFIX -> XMLConstants.XML_NS_URI;
case XMLConstants.XMLNS_ATTRIBUTE -> XMLConstants.XMLNS_ATTRIBUTE_NS_URI;
default -> {
- final ModuleEffectiveStatement module = prefixToModule.get(prefix);
+ final var module = prefixToModule.get(prefix);
yield module != null ? module.localQNameModule().getNamespace().toString() : XMLConstants.NULL_NS_URI;
}
};
case XMLConstants.XML_NS_URI -> XMLConstants.XML_NS_PREFIX;
case XMLConstants.XMLNS_ATTRIBUTE_NS_URI -> XMLConstants.XMLNS_ATTRIBUTE;
default -> {
- final List<@NonNull String> prefixes = namespaceToPrefix.get(namespaceURI);
+ final var prefixes = namespaceToPrefix.get(namespaceURI);
yield prefixes.isEmpty() ? null : prefixes.get(0);
}
};
import java.util.AbstractMap.SimpleImmutableEntry;
import java.util.Collection;
import java.util.HashMap;
-import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
if (haystack == needle) {
return true;
}
- for (DeclaredStatement<?> child : haystack.declaredSubstatements()) {
+ for (var child : haystack.declaredSubstatements()) {
if (contains(child, needle)) {
return true;
}
}
static StatementPrefixResolver forModule(final ModuleEffectiveStatement module) {
- final Map<QNameModule, String> imports = module.getAll(QNameModuleToPrefixNamespace.class);
- final Collection<SubmoduleEffectiveStatement> submodules = module.getAll(
- NameToEffectiveSubmoduleNamespace.class).values();
+ final var imports = module.getAll(QNameModuleToPrefixNamespace.class);
+ final var submodules = module.getAll(NameToEffectiveSubmoduleNamespace.class).values();
if (submodules.isEmpty()) {
// Simple: it's just the module
return new StatementPrefixResolver(imports);
}
// Stage one: check what everyone thinks about imports
- final Map<String, Multimap<QNameModule, EffectiveStatement<?, ?>>> prefixToNamespaces = new HashMap<>();
+ final var prefixToNamespaces = new HashMap<String, Multimap<QNameModule, EffectiveStatement<?, ?>>>();
indexPrefixes(prefixToNamespaces, imports, module);
- for (SubmoduleEffectiveStatement submodule : submodules) {
+ for (var submodule : submodules) {
indexPrefixes(prefixToNamespaces, submodule.getAll(QNameModuleToPrefixNamespace.class), submodule);
}
// Stage two: see what QNameModule -> prefix mappings there are. We will need to understand this in step three
- final Multimap<QNameModule, String> namespaceToPrefixes = HashMultimap.create();
- for (Entry<String, Multimap<QNameModule, EffectiveStatement<?,?>>> entry : prefixToNamespaces.entrySet()) {
- for (QNameModule namespace : entry.getValue().keySet()) {
+ final var namespaceToPrefixes = HashMultimap.<QNameModule, String>create();
+ for (var entry : prefixToNamespaces.entrySet()) {
+ for (var namespace : entry.getValue().keySet()) {
namespaceToPrefixes.put(namespace, entry.getKey());
}
}
final Builder<QNameModule, Object> builder = ImmutableMap.builderWithExpectedSize(prefixToNamespaces.size());
// ... first resolve unambiguous mappings ...
- final Iterator<Entry<String, Multimap<QNameModule, EffectiveStatement<?, ?>>>> it =
- prefixToNamespaces.entrySet().iterator();
+ final var it = prefixToNamespaces.entrySet().iterator();
while (it.hasNext()) {
- final Entry<String, Multimap<QNameModule, EffectiveStatement<?, ?>>> entry = it.next();
- final Multimap<QNameModule, EffectiveStatement<?, ?>> modules = entry.getValue();
+ final var entry = it.next();
+ final var modules = entry.getValue();
if (modules.size() == 1) {
// Careful now: the namespace needs to be unambiguous
- final QNameModule namespace = modules.keys().iterator().next();
+ final var namespace = modules.keys().iterator().next();
if (namespaceToPrefixes.get(namespace).size() == 1) {
builder.put(namespace, entry.getKey());
it.remove();
// .. check for any remaining conflicts ...
if (!prefixToNamespaces.isEmpty()) {
- final Multimap<QNameModule, Entry<DeclaredStatement<?>, String>> conflicts = ArrayListMultimap.create();
- for (Entry<String, Multimap<QNameModule, EffectiveStatement<?, ?>>> entry : prefixToNamespaces.entrySet()) {
- for (Entry<QNameModule, EffectiveStatement<?, ?>> namespace : entry.getValue().entries()) {
- conflicts.put(namespace.getKey(), new SimpleImmutableEntry<>(namespace.getValue().getDeclared(),
- entry.getKey()));
+ final var conflicts = ArrayListMultimap.<QNameModule, Entry<DeclaredStatement<?>, String>>create();
+ for (var entry : prefixToNamespaces.entrySet()) {
+ for (var namespaceEntry : entry.getValue().entries()) {
+ conflicts.put(namespaceEntry.getKey(),
+ new SimpleImmutableEntry<>(namespaceEntry.getValue().getDeclared(), entry.getKey()));
}
}
}
Optional<String> findPrefix(final DeclaredStatement<?> stmt) {
- final QNameModule module = stmt.statementDefinition().getStatementName().getModule();
+ final var module = stmt.statementDefinition().getStatementName().getModule();
if (YangConstants.RFC6020_YIN_MODULE.equals(module)) {
return Optional.empty();
}
- final Object obj = lookup.get(module);
+ final var obj = lookup.get(module);
if (obj != null) {
return decodeEntry(obj, stmt);
}
// - or DeclaredStatement should provide the prefix?
// The second one seems cleaner, as that means we would not have perform any lookup at all...
Entry<QNameModule, ?> match = null;
- for (Entry<QNameModule, ?> entry : lookup.entrySet()) {
- final QNameModule ns = entry.getKey();
+ for (var entry : lookup.entrySet()) {
+ final var ns = entry.getKey();
if (module.equals(ns.withoutRevision()) && (match == null
|| Revision.compare(match.getKey().getRevision(), ns.getRevision()) < 0)) {
match = entry;
private static void indexPrefixes(final Map<String, Multimap<QNameModule, EffectiveStatement<?, ?>>> map,
final Map<QNameModule, String> imports, final EffectiveStatement<?, ?> stmt) {
- for (Entry<QNameModule, String> entry : imports.entrySet()) {
+ for (var entry : imports.entrySet()) {
map.computeIfAbsent(entry.getValue(), key -> ArrayListMultimap.create()).put(entry.getKey(), stmt);
}
}
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import java.util.ArrayDeque;
-import java.util.Collection;
import java.util.Deque;
import java.util.Iterator;
-import java.util.Optional;
import java.util.Queue;
import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
* @return True if the statement was pushed. False if the statement was suppressed.
*/
private boolean pushStatement(final DeclaredStatement<?> stmt) {
- final StatementDefinition def = stmt.statementDefinition();
+ final var def = stmt.statementDefinition();
if (ignoredStatements.contains(def)) {
return false;
}
- final Collection<? extends DeclaredStatement<?>> children = stmt.declaredSubstatements();
+ final var children = stmt.declaredSubstatements();
if (omitDefaultStatements && children.isEmpty()) {
// This statement does not have substatements, check if its value matches the declared default, like
// "config true", "mandatory false", etc.
addIndent();
// Add statement prefixed with namespace if needed
- final Optional<String> prefix = resolver.findPrefix(stmt);
+ final var prefix = resolver.findPrefix(stmt);
if (prefix.isPresent()) {
strings.add(prefix.get());
strings.add(":");
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLStreamException;
import javax.xml.transform.OutputKeys;
-import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stax.StAXSource;
private static void writeReaderToOutput(final XMLEventReader reader, final OutputStream output)
throws XMLStreamException {
try {
- final Transformer transformer = TRANSFORMER_FACTORY.newTransformer();
+ final var transformer = TRANSFORMER_FACTORY.newTransformer();
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no");
transformer.transform(new StAXSource(reader), new StreamResult(output));
import java.util.Arrays;
import java.util.Deque;
import java.util.Iterator;
-import java.util.Map.Entry;
import java.util.NoSuchElementException;
-import java.util.Optional;
import java.util.Queue;
import javax.xml.XMLConstants;
import javax.xml.stream.XMLEventFactory;
@Override
public String getElementText() throws XMLStreamException {
- XMLEvent current = peek();
+ var current = peek();
if (current == null) {
throw new XMLStreamException("End of event stream");
}
@Override
public XMLEvent nextTag() throws XMLStreamException {
- final XMLEvent next = next();
+ final var next = next();
if (next instanceof Characters) {
throw new XMLStreamException("Significant characters encountered: " + next);
}
}
private Attribute attribute(final QName qname, final String value) {
- final Entry<String, String> ns = namespaceContext.prefixAndNamespaceFor(qname.getModule());
+ final var ns = namespaceContext.prefixAndNamespaceFor(qname.getModule());
return eventFactory.createAttribute(ns.getKey(), ns.getValue(), qname.getLocalName(), value);
}
private StartElement startElement(final QName qname) {
- final Entry<String, String> ns = namespaceContext.prefixAndNamespaceFor(qname.getModule());
+ final var ns = namespaceContext.prefixAndNamespaceFor(qname.getModule());
return eventFactory.createStartElement(ns.getKey(), ns.getValue(), qname.getLocalName(), emptyIterator(),
emptyIterator(), namespaceContext);
}
private EndElement endElement(final QName qname) {
- final Entry<String, String> ns = namespaceContext.prefixAndNamespaceFor(qname.getModule());
+ final var ns = namespaceContext.prefixAndNamespaceFor(qname.getModule());
return eventFactory.createEndElement(ns.getKey(), ns.getValue(), qname.getLocalName());
}
private void nextStatement() {
- final OpenElement current = stack.peek();
+ final var current = stack.peek();
if (current == null) {
return;
}
}
private void addStatement(final DeclaredStatement<?> statement) {
- final StatementDefinition def = statement.statementDefinition();
- final QName name = def.getStatementName();
- final Optional<ArgumentDefinition> optArgDef = def.getArgumentDefinition();
+ final var def = statement.statementDefinition();
+ final var name = def.getStatementName();
+ final var optArgDef = def.getArgumentDefinition();
if (optArgDef.isPresent()) {
- final ArgumentDefinition argDef = optArgDef.get();
- final QName argName = argDef.getArgumentName();
+ final var argDef = optArgDef.orElseThrow();
+ final var argName = argDef.getArgumentName();
if (argDef.isYinElement()) {
events.addAll(Arrays.asList(startElement(name), startElement(argName),
eventFactory.createCharacters(statement.rawArgument()), endElement(argName)));
} else {
- final Entry<String, String> ns = namespaceContext.prefixAndNamespaceFor(name.getModule());
+ final var ns = namespaceContext.prefixAndNamespaceFor(name.getModule());
events.add(eventFactory.createStartElement(ns.getKey(), ns.getValue(), name.getLocalName(),
singletonIterator(attribute(argName, statement.rawArgument())), emptyIterator(), namespaceContext));
}
import javax.xml.stream.XMLEventFactory;
import javax.xml.stream.XMLEventReader;
import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleEffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement;
/**
* Factory for creating {@link XMLEventReader} instances reporting events equivalent to reading a YIN document defining
private static final YinXMLEventReaderFactory DEFAULT;
static {
- final XMLEventFactory eventFactory = XMLEventFactory.newFactory();
+ final var eventFactory = XMLEventFactory.newFactory();
eventFactory.setLocation(DUMMY_LOCATION);
DEFAULT = new YinXMLEventReaderFactory(eventFactory);
}
* @throws IllegalArgumentException if the specified module does not expose declared model
*/
public XMLEventReader createXMLEventReader(final ModuleEffectiveStatement module) {
- final ModuleStatement declared = module.getDeclared();
+ final var declared = module.getDeclared();
checkArgument(declared != null, "Module %s does not expose declared model", module);
-
return new YinXMLEventReader(eventFactory, new ModuleNamespaceContext(module), declared);
}
*/
public XMLEventReader createXMLEventReader(final ModuleEffectiveStatement module,
final SubmoduleEffectiveStatement submodule) {
- final SubmoduleStatement declared = submodule.getDeclared();
+ final var declared = submodule.getDeclared();
checkArgument(declared != null, "Submodule %s does not expose declared model", submodule);
return new YinXMLEventReader(eventFactory, new ModuleNamespaceContext(module), declared);
}
Code Review / yangtools.git / commitdiff