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()); }
@Override protected NormalizedNode<?, ?> createEmptyValue(final NormalizedNode<?, ?> original) { checkArgument(original instanceof OrderedMapNode); return ImmutableOrderedMapNodeBuilder.create().withNodeIdentifier(((OrderedMapNode) original).getIdentifier()) .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(); }
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 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(); }
public static CollectionNodeBuilder<MapEntryNode, MapNode> mapNodeBuilder(final NodeIdentifier name) { return ImmutableMapNodeBuilder.create().withNodeIdentifier(name); }
.withChild(ImmutableNodes.leafNode(MYIDENTITY_QNAME, DESC_QNAME)) .withChild(Builders.unkeyedListBuilder() .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(UNKEYED_LIST_QNAME)) .withChild(unkeyedListEntry).build()) .withChild(Builders.choiceBuilder() .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TWO_THREE_QNAME)) .withChild(ImmutableNodes.leafNode(TWO_QNAME, "two")).build()) .withChild(Builders.orderedMapBuilder() .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(ORDERED_LIST_QNAME)) .withValue(ImmutableList.<MapEntryNode>builder().add( mapEntryBuilder(ORDERED_LIST_QNAME, ORDERED_LIST_ENTRY_QNAME, "1").build(), mapEntryBuilder(ORDERED_LIST_QNAME, ORDERED_LIST_ENTRY_QNAME, "2").build()).build()) .build()) .withChild(shoes) .withChild(numbers) .withChild(switchFeatures) .withChild(mapNodeBuilder(AUGMENTED_LIST_QNAME).withChild(augMapEntry).build()) .withChild(mapNodeBuilder(OUTER_LIST_QNAME) .withChild(mapEntry(OUTER_LIST_QNAME, ID_QNAME, ONE_ID)) .withChild(BAR_NODE).build() );
static MapNode candidateEntry(String candidateName) { return ImmutableOrderedMapNodeBuilder.create().withNodeIdentifier(new NodeIdentifier(Candidate.QNAME)). addChild(candidateMapEntry(candidateName)).build(); }
private void processMapEntries(final NormalizedNode<?, ?> node, final Integer depth, CollectionNodeBuilder<MapEntryNode, ? extends MapNode> newOrderedMapNodeBuilder) { if (depth > 1) { for (MapEntryNode oldMapEntryNode : ((MapNode) node).getValue()) { DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> newMapEntryNodeBuilder = Builders .mapEntryBuilder().withNodeIdentifier(oldMapEntryNode.getIdentifier()); for (DataContainerChild<? extends PathArgument, ?> mapEntryNodeValue : oldMapEntryNode.getValue()) { newMapEntryNodeBuilder.withChild(pruneDataAtDepth(mapEntryNodeValue, depth - 1)); } newOrderedMapNodeBuilder.withChild(newMapEntryNodeBuilder.build()); } } }
static MapEntryNode entityTypeEntryWithEntityEntry(String entityType, MapEntryNode entityNode) { return ImmutableNodes.mapEntryBuilder(EntityType.QNAME, ENTITY_TYPE_QNAME, entityType).addChild(ImmutableNodes.mapNodeBuilder( ENTITY_QNAME).addChild(entityNode).build()).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(); }
/** * 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(); }
public static CollectionNodeBuilder<MapEntryNode, MapNode> mapNodeBuilder(final NodeIdentifier name) { return ImmutableMapNodeBuilder.create().withNodeIdentifier(name); }
static ContainerNode entityOwnersWithEntityTypeEntry(MapEntryNode entityTypeNode) { return ImmutableContainerNodeBuilder.create().withNodeIdentifier( ENTITY_OWNERS_NODE_ID).addChild(ImmutableNodes.mapNodeBuilder(EntityType.QNAME). addChild(entityTypeNode).build()).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(); }
/** * 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(); }
@VisibleForTesting static DataContainerChild<?, ?> wrapListIntoMixinNode( final Collection<NormalizedNode<?, ?>> normalizedRootElements, final ListSchemaNode listSchema) { if (listSchema.getKeyDefinition().isEmpty()) { final CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> listBuilder = Builders.unkeyedListBuilder(); listBuilder.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listSchema.getQName())); for (NormalizedNode<?, ?> normalizedRootElement : normalizedRootElements) { listBuilder.withChild((UnkeyedListEntryNode) normalizedRootElement); } return listBuilder.build(); } else { final CollectionNodeBuilder<MapEntryNode, ? extends MapNode> listBuilder = listSchema.isUserOrdered() ? Builders.orderedMapBuilder() : Builders.mapBuilder(); listBuilder.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listSchema.getQName())); for (NormalizedNode<?, ?> normalizedRootElement : normalizedRootElements) { listBuilder.withChild((MapEntryNode) normalizedRootElement); } return listBuilder.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(); }
@Override CollectionNodeBuilder<MapEntryNode, OrderedMapNode> createBuilder(final PathArgument compositeNode) { return Builders.orderedMapBuilder().withNodeIdentifier(getIdentifier()); } }
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(); } }