@Override public Iterable<? extends NormalizedNodeMessages.PathArgumentAttribute> get( QNameSerializationContext context, YangInstanceIdentifier.PathArgument pathArgument) { YangInstanceIdentifier.NodeIdentifierWithPredicates identifier = (YangInstanceIdentifier.NodeIdentifierWithPredicates) pathArgument; Map<QName, Object> keyValues = identifier.getKeyValues(); List<NormalizedNodeMessages.PathArgumentAttribute> attributes = new ArrayList<>(keyValues.size()); for (Entry<QName, Object> e : keyValues.entrySet()) { NormalizedNodeMessages.PathArgumentAttribute attribute = buildAttribute(context, e.getKey(), e.getValue()); attributes.add(attribute); } return attributes; } });
@Override protected String getServiceIdentifierFromEntity(final DOMEntity entity) { final YangInstanceIdentifier yii = entity.getIdentifier(); final NodeIdentifierWithPredicates niiwp = (NodeIdentifierWithPredicates) yii.getLastPathArgument(); return niiwp.getKeyValues().values().iterator().next().toString(); } }
private static YangInstanceIdentifier extractEntityPath(YangInstanceIdentifier candidatePath) { 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; } } } return YangInstanceIdentifier.create(newPathArgs); } }
@Override public MapEntryNode build() { for (final Entry<QName, Object> key : getNodeIdentifier().getKeyValues().entrySet()) { final DataContainerChild<?, ?> childNode = getChild(childrenQNamesToPaths.get(key.getKey())); // We have enough information to fill-in missing leaf nodes, so let's do that if (childNode == null) { LeafNode<Object> leaf = ImmutableNodes.leafNode(key.getKey(), key.getValue()); LOG.debug("Adding leaf {} implied by key {}", leaf, key); withChild(leaf); } else { DataValidationException.checkListKey(getNodeIdentifier(), key.getKey(), key.getValue(), childNode.getValue()); } } return new ImmutableMapEntryNode(getNodeIdentifier(), buildValue(), getAttributes()); }
@Override @SuppressFBWarnings("BC_UNCONFIRMED_CAST") public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) { final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder = Builders .mapEntryBuilder().withNodeIdentifier((NodeIdentifierWithPredicates) currentArg); for (final Entry<QName, Object> keyValue : ((NodeIdentifierWithPredicates) currentArg).getKeyValues().entrySet()) { builder.addChild(Builders.leafBuilder() // .withNodeIdentifier(new NodeIdentifier(keyValue.getKey())).withValue(keyValue.getValue()) .build()); } return builder.build(); }
public static PeerId peerId(final NodeIdentifierWithPredicates peerKey) { // We could use a codec, but this is simple enough return new PeerId((String) peerKey.getKeyValues().get(PEER_ID)); }
@Override DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> createBuilder( final PathArgument currentArg) { final NodeIdentifierWithPredicates arg = (NodeIdentifierWithPredicates) currentArg; final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder = Builders .mapEntryBuilder().withNodeIdentifier(arg); for (final Entry<QName, Object> keyValue : arg.getKeyValues().entrySet()) { builder.addChild(Builders.leafBuilder() .withNodeIdentifier(NodeIdentifier.create(keyValue.getKey())).withValue(keyValue.getValue()) .build()); } return builder; }
private NodeIdentifierWithPredicates transform(final NodeIdentifierWithPredicates identifier) { Map<QName, Object> keyValues = new HashMap<>(); for (Map.Entry<QName, Object> original : identifier.getKeyValues().entrySet()) { keyValues.put(transform(original.getKey()), original.getValue()); } return new NodeIdentifierWithPredicates(transform(identifier.getNodeType()), keyValues); } }
@Override public void ownershipChanged(EntityOwnershipChange ownershipChange) { YangInstanceIdentifier yId = ownershipChange.getEntity().getId(); NodeIdentifierWithPredicates niWPredicates = (NodeIdentifierWithPredicates)yId.getLastPathArgument(); Map<QName, Object> keyValMap = niWPredicates.getKeyValues(); String nodeIdStr = (String)(keyValMap.get(ENTITY_NAME)); NodeId nodeId = new NodeId(nodeIdStr); setNodeOwnership(nodeId, ownershipChange.isOwner()); }
@Override @SuppressWarnings({ "rawtypes", "unchecked", "checkstyle:illegalCatch" }) public final IdentifiableItem<?, ?> deserialize(final NodeIdentifierWithPredicates input) { final Identifier<?> identifier; try { identifier = deserializeIdentifier(input.getKeyValues()); } catch (Throwable e) { Throwables.throwIfUnchecked(e); throw new RuntimeException(e); } return IdentifiableItem.of((Class) identifiable, (Identifier) identifier); }
private static String toStringTree(final PathArgument identifier) { if (identifier instanceof NodeIdentifierWithPredicates) { return identifier.getNodeType().getLocalName() + ((NodeIdentifierWithPredicates) identifier).getKeyValues().values(); } else if (identifier instanceof AugmentationIdentifier) { return "augmentation"; } else { return identifier.getNodeType().getLocalName(); } }
private static String toString(NodeIdentifierWithPredicates pathArgument){ return pathArgument.getNodeType().toString() + '[' + pathArgument.getKeyValues() + ']'; }
private InstanceIdentifier<Node> obtainNodeIdFromEntity(Entity entity) { LOG.debug ("in obtainNodeIdFromEntity for entity {}", entity.getId()); NodeIdentifierWithPredicates node = (NodeIdentifierWithPredicates)entity.getId().getLastPathArgument(); String nodeValue = (String)node.getKeyValues().values().iterator().next(); InstanceIdentifier<Node> nodeId = InstanceIdentifier.builder(Nodes.class) .child(Node.class, new NodeKey(new NodeId(nodeValue))).toInstance(); LOG.debug("nodeid returned for entity {}", nodeId); return nodeId; }
protected boolean writeMapEntryChildren(final MapEntryNode mapEntryNode) throws IOException { if (currentDepth < maxDepth) { writeChildren(mapEntryNode.getValue()); } else if (currentDepth == maxDepth) { writeOnlyKeys(mapEntryNode.getIdentifier().getKeyValues()); } return true; }
@Override public void startMapEntryNode(final NodeIdentifierWithPredicates identifier, final int childSizeHint) throws IOException, IllegalArgumentException { Preconditions.checkNotNull(identifier, "Node identifier should not be null"); LOG.debug("Starting a new map entry node"); startNode(identifier.getNodeType(), NodeTypes.MAP_ENTRY_NODE); writeKeyValueMap(identifier.getKeyValues()); }
@Override DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> createBuilder( final PathArgument currentArg) { final NodeIdentifierWithPredicates arg = (NodeIdentifierWithPredicates) currentArg; final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder = Builders .mapEntryBuilder().withNodeIdentifier(arg); for (final Entry<QName, Object> keyValue : arg.getKeyValues().entrySet()) { builder.addChild(Builders.leafBuilder() .withNodeIdentifier(NodeIdentifier.create(keyValue.getKey())).withValue(keyValue.getValue()) .build()); } return builder; }
private static String toStringTree(final PathArgument identifier) { if (identifier instanceof NodeIdentifierWithPredicates) { return identifier.getNodeType().getLocalName() + ((NodeIdentifierWithPredicates) identifier).getKeyValues().values(); } else if (identifier instanceof AugmentationIdentifier) { return "augmentation"; } else { return identifier.getNodeType().getLocalName(); } }
public static String entityTypeFromEntityPath(YangInstanceIdentifier entityPath){ YangInstanceIdentifier parent = entityPath; while(!parent.isEmpty()) { if (EntityType.QNAME.equals(parent.getLastPathArgument().getNodeType())) { YangInstanceIdentifier.NodeIdentifierWithPredicates entityTypeLastPathArgument = (YangInstanceIdentifier.NodeIdentifierWithPredicates) parent.getLastPathArgument(); return (String) entityTypeLastPathArgument.getKeyValues().get(ENTITY_TYPE_QNAME); } parent = parent.getParent(); } return null; }
private void installAdjRibInTables(final YangInstanceIdentifier newPeerPath, final TablesKey tableKey, final RIBSupportContext rs, final NodeIdentifierWithPredicates instanceIdentifierKey, final DOMDataWriteTransaction tx, final Builder<TablesKey, TableContext> tb) { // We will use table keys very often, make sure they are optimized final InstanceIdentifierBuilder idb = YangInstanceIdentifier.builder(newPeerPath.node(EMPTY_ADJRIBIN.getIdentifier()).node(TABLES)); idb.nodeWithKey(instanceIdentifierKey.getNodeType(), instanceIdentifierKey.getKeyValues()); final TableContext ctx = new TableContext(rs, idb.build()); ctx.createEmptyTableStructure(tx); tx.merge(LogicalDatastoreType.OPERATIONAL, ctx.getTableId().node(Attributes.QNAME).node(ATTRIBUTES_UPTODATE_FALSE.getNodeType()), ATTRIBUTES_UPTODATE_FALSE); LOG.debug("Created table instance {}", ctx.getTableId()); tb.put(tableKey, ctx); }
@Override public void startMapEntryNode(final NodeIdentifierWithPredicates identifier, final int childSizeHint) throws IOException, IllegalArgumentException { Preconditions.checkNotNull(identifier, "Node identifier should not be null"); LOG.trace("Starting a new map entry node"); startNode(identifier.getNodeType(), NodeTypes.MAP_ENTRY_NODE); writeKeyValueMap(identifier.getKeyValues()); }