/** * Create immutable ordered map node. * * @param name QName which will be used as node identifier * @return An ordered Map node */ public static OrderedMapNode orderedMapNode(final QName name) { return orderedMapNodeBuilder(name).build(); }
/** * Create an immutable map node. * * @param name QName which will be used as node identifier * @return An unordered Map node */ public static MapNode mapNode(final QName name) { return mapNodeBuilder(name).build(); }
/** * Create an immutable map node. * * @param name QName which will be used as node identifier * @return An unordered Map node */ public static MapNode mapNode(final QName name) { return mapNodeBuilder(name).build(); }
/** * Create immutable ordered map node. * * @param name QName which will be used as node identifier * @return An ordered Map node */ public static OrderedMapNode orderedMapNode(final QName name) { return orderedMapNodeBuilder(name).build(); }
private Optional<MapNode> build(ListSchemaNode schema, Map<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> resultNodes) { if(resultNodes.isEmpty()) { return Optional.absent(); } CollectionNodeBuilder<MapEntryNode, MapNode> b = Builders.mapBuilder(schema); for (MapEntryNode child : resultNodes.values()) { b.withChild(child); } return Optional.of(b.build()); }
private DataContainerChild<?, ?> processMapNode(final NormalizedNode<?, ?> node, final Integer depth) { CollectionNodeBuilder<MapEntryNode, MapNode> newMapNodeBuilder = Builders.mapBuilder(); processMapEntries(node, depth, newMapNodeBuilder); return newMapNodeBuilder.build(); }
private DataContainerChild<?, ?> processOrderedMapNode(final NormalizedNode<?, ?> node, final Integer depth) { CollectionNodeBuilder<MapEntryNode, OrderedMapNode> newOrderedMapNodeBuilder = Builders.orderedMapBuilder(); processMapEntries(node, depth, newOrderedMapNodeBuilder); return newOrderedMapNodeBuilder.build(); }
@Override protected NormalizedNode<?, ?> createEmptyValue(final NormalizedNode<?, ?> original) { checkArgument(original instanceof OrderedMapNode); return ImmutableOrderedMapNodeBuilder.create().withNodeIdentifier(((OrderedMapNode) original).getIdentifier()) .build(); }
private Optional<UnkeyedListNode> build(ListSchemaNode schema, List<UnkeyedListEntryNode> resultNodes) { if (resultNodes.isEmpty()) { return Optional.absent(); } CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> b = Builders.unkeyedListBuilder(); b.withNodeIdentifier(new NodeIdentifier(schema.getQName())); for (UnkeyedListEntryNode child : resultNodes) { b.withChild(child); } return Optional.of(b.build()); }
/** * Create an immutable list node. * * @param name QName which will be used as node identifier * @return An unkeyed list node */ public static UnkeyedListNode listNode(final QName name) { return ImmutableUnkeyedListNodeBuilder.create().withNodeIdentifier(NodeIdentifier.create(name)).build(); }
/** * Create an immutable list node. * * @param name QName which will be used as node identifier * @return An unkeyed list node */ public static UnkeyedListNode listNode(final QName name) { return ImmutableUnkeyedListNodeBuilder.create().withNodeIdentifier(NodeIdentifier.create(name)).build(); }
private static MapNode initInnerListItems(final int count) { final CollectionNodeBuilder<MapEntryNode, MapNode> mapEntryBuilder = ImmutableNodes .mapNodeBuilder(BenchmarkModel.INNER_LIST); for (int i = 0; i < count; ++i) { mapEntryBuilder .withChild(ImmutableNodes.mapEntry(BenchmarkModel.INNER_LIST_QNAME, BenchmarkModel.NAME_QNAME, i)); } return mapEntryBuilder.build(); }
static private MapNode buildInnerList(int index, int elements ) { CollectionNodeBuilder<MapEntryNode, MapNode> innerList = ImmutableNodes.mapNodeBuilder(InnerList.QNAME); final String itemStr = "Item-" + String.valueOf(index) + "-"; for( int i = 0; i < elements; i++ ) { innerList.addChild(ImmutableNodes.mapEntryBuilder() .withNodeIdentifier(new NodeIdentifierWithPredicates(InnerList.QNAME, IL_NAME, i)) .withChild(ImmutableNodes.leafNode(IL_NAME, i)) .withChild(ImmutableNodes.leafNode(IL_VALUE, itemStr + String.valueOf(i))) .build()); } return innerList.build(); }
@Override protected NormalizedNode<?, ?> createEmptyValue(final NormalizedNode<?, ?> original) { return original instanceof MapNode ? ImmutableMapNodeBuilder.create() .withNodeIdentifier(((MapNode) original).getIdentifier()).build() : super.createEmptyValue(original); } }
@Override protected NormalizedNode<?, ?> createEmptyValue(final NormalizedNode<?, ?> original) { return original instanceof OrderedMapNode ? ImmutableOrderedMapNodeBuilder.create() .withNodeIdentifier(((OrderedMapNode) original).getIdentifier()).build() : super.createEmptyValue(original); } }
@Override protected NormalizedNode<?, ?> createEmptyValue(final NormalizedNode<?, ?> original) { if (original instanceof MapNode) { return ImmutableMapNodeBuilder.create().withNodeIdentifier(((MapNode) original).getIdentifier()).build(); } else if (original instanceof MapEntryNode) { return ImmutableMapEntryNodeBuilder.create().withNodeIdentifier( ((MapEntryNode) original).getIdentifier()).build(); } throw new IllegalArgumentException("MapModification strategy can only handle MapNode or MapEntryNode's, " + "offending node: " + original); }
private static MapNode buildInnerList(final int index, final int elements) { CollectionNodeBuilder<MapEntryNode, MapNode> innerList = ImmutableNodes.mapNodeBuilder(InnerList.QNAME); final String itemStr = "Item-" + String.valueOf(index) + "-"; for (int i = 0; i < elements; i++) { innerList.addChild(ImmutableNodes.mapEntryBuilder() .withNodeIdentifier(new NodeIdentifierWithPredicates(InnerList.QNAME, IL_NAME, i)) .withChild(ImmutableNodes.leafNode(IL_NAME, i)) .withChild(ImmutableNodes.leafNode(IL_VALUE, itemStr + String.valueOf(i))) .build()); } return innerList.build(); } }
private NormalizedNode<?, ?> buildCollectionNode( final CollectionNodeBuilder builder, final NormalizedNodeMessages.Node node) { builder.withNodeIdentifier(toNodeIdentifier(node.getPathArgument())); for(NormalizedNodeMessages.Node child : node.getChildList()){ builder.withChild(deSerialize(child)); } return builder.build(); }
private static void ensureParentExists(final DOMDataWriteTransaction wTx, final YangInstanceIdentifier path) { final ContainerNode parentNode = Builders.containerBuilder().withNodeIdentifier( new NodeIdentifier(BmpMonitor.QNAME)).addChild(ImmutableNodes.mapNodeBuilder(Monitor.QNAME).build()).build(); wTx.merge(LogicalDatastoreType.OPERATIONAL, path, parentNode); }
private void createRouterEntry() { Preconditions.checkState(isDatastoreWritable()); final DOMDataWriteTransaction wTx = this.domTxChain.newWriteOnlyTransaction(); wTx.put(LogicalDatastoreType.OPERATIONAL, this.routerYangIId, Builders.mapEntryBuilder() .withNodeIdentifier(new NodeIdentifierWithPredicates(Router.QNAME, ROUTER_ID_QNAME, this.routerIp)) .withChild(ImmutableNodes.leafNode(ROUTER_ID_QNAME, routerIp)) .withChild(ImmutableNodes.leafNode(ROUTER_STATUS_QNAME, DOWN)) .withChild(ImmutableNodes.mapNodeBuilder(Peer.QNAME).build()).build()); wTx.submit(); }