import java.io.StringWriter;
import java.nio.charset.StandardCharsets;
import java.util.Collection;
-import java.util.Map;
+import java.util.Map.Entry;
import java.util.Set;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
LOG.trace("Starting a new map entry node");
startNode(identifier.getNodeType(), NodeTypes.MAP_ENTRY_NODE);
- writeKeyValueMap(identifier.getKeyValues());
+ writeKeyValueMap(identifier.entrySet());
}
@Override
(NodeIdentifierWithPredicates) pathArgument;
writeQName(nodeIdentifierWithPredicates.getNodeType());
- writeKeyValueMap(nodeIdentifierWithPredicates.getKeyValues());
+ writeKeyValueMap(nodeIdentifierWithPredicates.entrySet());
break;
case PathArgumentTypes.NODE_IDENTIFIER_WITH_VALUE :
}
}
- private void writeKeyValueMap(final Map<QName, Object> keyValueMap) throws IOException {
- if (keyValueMap != null && !keyValueMap.isEmpty()) {
- output.writeInt(keyValueMap.size());
-
- for (Map.Entry<QName, Object> entry : keyValueMap.entrySet()) {
+ private void writeKeyValueMap(final Set<Entry<QName, Object>> entrySet) throws IOException {
+ if (!entrySet.isEmpty()) {
+ output.writeInt(entrySet.size());
+ for (Entry<QName, Object> entry : entrySet) {
writeQName(entry.getKey());
writeObject(entry.getValue());
}
public abstract DataNormalizationOperation<?> getChild(QName child) throws DataNormalizationException;
-
public abstract boolean isLeaf();
public Optional<DataSchemaNode> getDataSchemaNode() {
private abstract static class SimpleTypeNormalization<T extends PathArgument>
extends DataNormalizationOperation<T> {
-
- protected SimpleTypeNormalization(final T identifier, final DataSchemaNode potential) {
+ SimpleTypeNormalization(final T identifier, final DataSchemaNode potential) {
super(identifier,potential);
}
}
private static final class LeafNormalization extends SimpleTypeNormalization<NodeIdentifier> {
-
- protected LeafNormalization(final LeafSchemaNode potential) {
+ LeafNormalization(final LeafSchemaNode potential) {
super(new NodeIdentifier(potential.getQName()),potential);
}
-
}
private static final class LeafListEntryNormalization extends SimpleTypeNormalization<NodeWithValue> {
-
LeafListEntryNormalization(final LeafListSchemaNode potential) {
super(new NodeWithValue(potential.getQName(), null),potential);
}
private abstract static class CompositeNodeNormalizationOperation<T extends PathArgument>
extends DataNormalizationOperation<T> {
-
- protected CompositeNodeNormalizationOperation(final T identifier, final DataSchemaNode schema) {
+ CompositeNodeNormalizationOperation(final T identifier, final DataSchemaNode schema) {
super(identifier,schema);
}
public boolean isLeaf() {
return false;
}
-
-
}
private abstract static class DataContainerNormalizationOperation<T extends PathArgument>
extends CompositeNodeNormalizationOperation<T> {
-
private final DataNodeContainer schema;
private final Map<QName, DataNormalizationOperation<?>> byQName;
private final Map<PathArgument, DataNormalizationOperation<?>> byArg;
- protected DataContainerNormalizationOperation(final T identifier, final DataNodeContainer schema,
+ DataContainerNormalizationOperation(final T identifier, final DataNodeContainer schema,
final DataSchemaNode node) {
super(identifier,node);
this.schema = schema;
}
return potential;
}
-
}
private static final class ListItemNormalization extends
DataContainerNormalizationOperation<NodeIdentifierWithPredicates> {
-
- protected ListItemNormalization(final NodeIdentifierWithPredicates identifier, final ListSchemaNode schema) {
+ ListItemNormalization(final NodeIdentifierWithPredicates identifier, final ListSchemaNode schema) {
super(identifier, schema, schema);
}
public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder = Builders
.mapEntryBuilder().withNodeIdentifier((NodeIdentifierWithPredicates) currentArg);
- for (final Entry<QName, Object> keyValue :
- ((NodeIdentifierWithPredicates) currentArg).getKeyValues().entrySet()) {
+ for (final Entry<QName, Object> keyValue : ((NodeIdentifierWithPredicates) currentArg).entrySet()) {
builder.addChild(Builders.leafBuilder()
//
.withNodeIdentifier(new NodeIdentifier(keyValue.getKey())).withValue(keyValue.getValue())
return builder.build();
}
-
@Override
public boolean isKeyedEntry() {
return true;
private static final class UnkeyedListItemNormalization
extends DataContainerNormalizationOperation<NodeIdentifier> {
-
- protected UnkeyedListItemNormalization(final ListSchemaNode schema) {
+ UnkeyedListItemNormalization(final ListSchemaNode schema) {
super(new NodeIdentifier(schema.getQName()), schema,schema);
}
public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
return Builders.unkeyedListEntryBuilder().withNodeIdentifier((NodeIdentifier) currentArg).build();
}
-
}
private static final class ContainerNormalization extends DataContainerNormalizationOperation<NodeIdentifier> {
-
- protected ContainerNormalization(final ContainerSchemaNode schema) {
+ ContainerNormalization(final ContainerSchemaNode schema) {
super(new NodeIdentifier(schema.getQName()),schema, schema);
}
public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
return Builders.containerBuilder().withNodeIdentifier((NodeIdentifier) currentArg).build();
}
-
}
private abstract static class MixinNormalizationOp<T extends PathArgument>
extends CompositeNodeNormalizationOperation<T> {
- protected MixinNormalizationOp(final T identifier, final DataSchemaNode schema) {
+ MixinNormalizationOp(final T identifier, final DataSchemaNode schema) {
super(identifier,schema);
}
public final boolean isMixin() {
return true;
}
-
}
-
private static final class OrderedLeafListMixinNormalization extends UnorderedLeafListMixinNormalization {
OrderedLeafListMixinNormalization(final LeafListSchemaNode potential) {
super(potential);
return true;
}
-
-
@Override
protected DataNormalizationOperation<?> fromLocalSchemaAndQName(final DataNodeContainer schema,
final QName child) {
}
private static class UnorderedMapMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
-
private final ListItemNormalization innerNode;
UnorderedMapMixinNormalization(final ListSchemaNode list) {
}
return null;
}
-
}
-
private static class UnkeyedListMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
-
private final UnkeyedListItemNormalization innerNode;
UnkeyedListMixinNormalization(final ListSchemaNode list) {
}
return null;
}
-
}
private static final class OrderedMapMixinNormalization extends UnorderedMapMixinNormalization {
-
OrderedMapMixinNormalization(final ListSchemaNode list) {
super(list);
}
public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
return Builders.orderedMapBuilder().withNodeIdentifier(getIdentifier()).build();
}
-
}
private static class ChoiceNodeNormalization extends MixinNormalizationOp<NodeIdentifier> {
-
private final ImmutableMap<QName, DataNormalizationOperation<?>> byQName;
private final ImmutableMap<PathArgument, DataNormalizationOperation<?>> byArg;
- protected ChoiceNodeNormalization(final ChoiceSchemaNode schema) {
+ ChoiceNodeNormalization(final ChoiceSchemaNode schema) {
super(new NodeIdentifier(schema.getQName()),schema);
final ImmutableMap.Builder<QName, DataNormalizationOperation<?>> byQNameBuilder = ImmutableMap.builder();
final ImmutableMap.Builder<PathArgument, DataNormalizationOperation<?>> byArgBuilder =
}
private static class AnyXmlNormalization extends DataNormalizationOperation<NodeIdentifier> {
-
- protected AnyXmlNormalization(final AnyXmlSchemaNode schema) {
+ AnyXmlNormalization(final AnyXmlSchemaNode schema) {
super(new NodeIdentifier(schema.getQName()), schema);
}
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
-import java.util.Map.Entry;
import java.util.Optional;
import org.opendaylight.controller.cluster.datastore.ShardDataTree;
import org.opendaylight.controller.cluster.datastore.entityownership.messages.CandidateAdded;
import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.clustering.entity.owners.rev150804.entity.owners.EntityType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.clustering.entity.owners.rev150804.entity.owners.entity.type.entity.Candidate;
-import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
NodeIdentifierWithPredicates candidateKey =
(NodeIdentifierWithPredicates) change.getRootPath().getLastPathArgument();
- String candidate = candidateKey.getKeyValues().get(CANDIDATE_NAME_QNAME).toString();
+ String candidate = candidateKey.getValue(CANDIDATE_NAME_QNAME).toString();
YangInstanceIdentifier entityId = extractEntityPath(change.getRootPath());
List<PathArgument> newPathArgs = new ArrayList<>();
for (PathArgument pathArg: candidatePath.getPathArguments()) {
newPathArgs.add(pathArg);
- if (pathArg instanceof NodeIdentifierWithPredicates) {
- NodeIdentifierWithPredicates nodeKey = (NodeIdentifierWithPredicates) pathArg;
- Entry<QName, Object> key = nodeKey.getKeyValues().entrySet().iterator().next();
- if (ENTITY_ID_QNAME.equals(key.getKey())) {
- break;
- }
+ if (pathArg instanceof NodeIdentifierWithPredicates
+ && ENTITY_ID_QNAME.equals(((NodeIdentifierWithPredicates) pathArg).keySet().iterator().next())) {
+ break;
}
}
*/
public final class EntityOwnersModel {
static final QName ENTITY_QNAME = Entity.QNAME;
- static final QName CANDIDATE_NAME_QNAME = QName.create(Candidate.QNAME, "name");
- static final QName ENTITY_ID_QNAME = QName.create(ENTITY_QNAME, "id");
- static final QName ENTITY_OWNER_QNAME = QName.create(ENTITY_QNAME, "owner");
- static final QName ENTITY_TYPE_QNAME = QName.create(EntityType.QNAME, "type");
-
- static final NodeIdentifier ENTITY_OWNERS_NODE_ID = new NodeIdentifier(EntityOwners.QNAME);
- static final NodeIdentifier ENTITY_OWNER_NODE_ID = new NodeIdentifier(ENTITY_OWNER_QNAME);
- static final NodeIdentifier ENTITY_NODE_ID = new NodeIdentifier(ENTITY_QNAME);
- static final NodeIdentifier ENTITY_ID_NODE_ID = new NodeIdentifier(ENTITY_ID_QNAME);
- static final NodeIdentifier ENTITY_TYPE_NODE_ID = new NodeIdentifier(ENTITY_TYPE_QNAME);
- static final NodeIdentifier CANDIDATE_NODE_ID = new NodeIdentifier(Candidate.QNAME);
- static final NodeIdentifier CANDIDATE_NAME_NODE_ID = new NodeIdentifier(CANDIDATE_NAME_QNAME);
- static final YangInstanceIdentifier ENTITY_OWNERS_PATH = YangInstanceIdentifier.of(EntityOwners.QNAME);
- static final YangInstanceIdentifier ENTITY_TYPES_PATH =
- YangInstanceIdentifier.of(EntityOwners.QNAME).node(EntityType.QNAME);
+ static final QName CANDIDATE_NAME_QNAME = QName.create(Candidate.QNAME, "name").intern();
+ static final QName ENTITY_ID_QNAME = QName.create(ENTITY_QNAME, "id").intern();
+ static final QName ENTITY_OWNER_QNAME = QName.create(ENTITY_QNAME, "owner").intern();
+ static final QName ENTITY_TYPE_QNAME = QName.create(EntityType.QNAME, "type").intern();
+
+ static final NodeIdentifier ENTITY_OWNERS_NODE_ID = NodeIdentifier.create(EntityOwners.QNAME);
+ static final NodeIdentifier ENTITY_OWNER_NODE_ID = NodeIdentifier.create(ENTITY_OWNER_QNAME);
+ static final NodeIdentifier ENTITY_NODE_ID = NodeIdentifier.create(ENTITY_QNAME);
+ static final NodeIdentifier ENTITY_ID_NODE_ID = NodeIdentifier.create(ENTITY_ID_QNAME);
+ static final NodeIdentifier ENTITY_TYPE_NODE_ID = NodeIdentifier.create(ENTITY_TYPE_QNAME);
+ static final NodeIdentifier CANDIDATE_NODE_ID = NodeIdentifier.create(Candidate.QNAME);
+ static final NodeIdentifier CANDIDATE_NAME_NODE_ID = NodeIdentifier.create(CANDIDATE_NAME_QNAME);
+ static final YangInstanceIdentifier ENTITY_OWNERS_PATH = YangInstanceIdentifier.create(ENTITY_OWNERS_NODE_ID);
+ static final YangInstanceIdentifier ENTITY_TYPES_PATH = ENTITY_OWNERS_PATH.node(EntityType.QNAME).toOptimized();
private static final SharedSingletonMapTemplate<QName> NODE_KEY_TEMPLATE = SharedSingletonMapTemplate.ordered(
CANDIDATE_NAME_QNAME);
if (EntityType.QNAME.equals(parent.getLastPathArgument().getNodeType())) {
YangInstanceIdentifier.NodeIdentifierWithPredicates entityTypeLastPathArgument =
(YangInstanceIdentifier.NodeIdentifierWithPredicates) parent.getLastPathArgument();
- return (String) entityTypeLastPathArgument.getKeyValues().get(ENTITY_TYPE_QNAME);
+ return (String) entityTypeLastPathArgument.getValue(ENTITY_TYPE_QNAME);
}
parent = parent.getParent();
}
for (PathArgument pathArg: entityPath.getPathArguments()) {
if (pathArg instanceof NodeIdentifierWithPredicates) {
NodeIdentifierWithPredicates nodeKey = (NodeIdentifierWithPredicates) pathArg;
- Entry<QName, Object> key = nodeKey.getKeyValues().entrySet().iterator().next();
+ Entry<QName, Object> key = nodeKey.entrySet().iterator().next();
if (ENTITY_TYPE_QNAME.equals(key.getKey())) {
entityType = key.getValue().toString();
} else if (ENTITY_ID_QNAME.equals(key.getKey())) {
final List<Modification> modifications = new ArrayList<>();
searchForEntities((entityTypeNode, entityNode) -> {
if (hasCandidate(entityNode, member)) {
- YangInstanceIdentifier entityId =
- (YangInstanceIdentifier) entityNode.getIdentifier().getKeyValues().get(ENTITY_ID_QNAME);
- YangInstanceIdentifier candidatePath = candidatePath(
- entityTypeNode.getIdentifier().getKeyValues().get(ENTITY_TYPE_QNAME).toString(),
- entityId, member.getName());
+ YangInstanceIdentifier entityId = (YangInstanceIdentifier) entityNode.getIdentifier()
+ .getValue(ENTITY_ID_QNAME);
+ YangInstanceIdentifier candidatePath = candidatePath(entityTypeNode.getIdentifier()
+ .getValue(ENTITY_TYPE_QNAME).toString(), entityId, member.getName());
LOG.info("{}: Found entity {}, removing candidate {}, path {}", persistenceId(), entityId,
member, candidatePath);
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.controller.cluster.datastore.utils;
import org.opendaylight.controller.cluster.access.concepts.MemberName;
builder.append(p.getNodeType().getLocalName());
if (p instanceof NodeIdentifierWithPredicates) {
builder.append("-key_");
- ((NodeIdentifierWithPredicates) p).getKeyValues().forEach((key, value) -> {
- builder.append(key.getLocalName());
- builder.append(value);
- builder.append("-");
+ ((NodeIdentifierWithPredicates) p).entrySet().forEach(entry -> {
+ builder.append(entry.getKey().getLocalName()).append(entry.getValue()).append('-');
});
- builder.append("_");
+ builder.append('_');
}
- builder.append("!");
+ builder.append('!');
});
return builder.toString();
}