@Override @SuppressFBWarnings("BC_UNCONFIRMED_CAST") public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) { return Builders.unkeyedListEntryBuilder().withNodeIdentifier((NodeIdentifier) currentArg).build(); }
@Override public NormalizedNode<?, ?> apply(final DeSerializer deSerializer, final NormalizedNodeMessages.Node node) { DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> builder = Builders.containerBuilder() .withNodeIdentifier(deSerializer.toNodeIdentifier(node.getPathArgument())); return deSerializer.buildDataContainer(builder, node); } });
@Override DataContainerNodeAttrBuilder<NodeIdentifier, UnkeyedListEntryNode> createBuilder( final PathArgument compositeNode) { return Builders.unkeyedListEntryBuilder().withNodeIdentifier(getIdentifier()); }
@Override protected NormalizedNode<?, ?> createEmptyValue(final NormalizedNode<?, ?> original) { Preconditions.checkArgument(original instanceof ContainerNode); return ImmutableContainerNodeBuilder.create().withNodeIdentifier(((ContainerNode) original).getIdentifier()) .build(); } }
@Override public void startUnkeyedListItem(YangInstanceIdentifier.NodeIdentifier nodeIdentifier, int i) throws IOException, IllegalStateException { checkNotSealed(); addBuilder(Builders.unkeyedListEntryBuilder().withNodeIdentifier(nodeIdentifier), nodeIdentifier); }
@Override public void startContainerNode(YangInstanceIdentifier.NodeIdentifier nodeIdentifier, int count) throws IllegalArgumentException { checkNotSealed(); addBuilder(Builders.containerBuilder().withNodeIdentifier(nodeIdentifier), nodeIdentifier); }
@Override public void startYangModeledAnyXmlNode(final NodeIdentifier name, final int childSizeHint) { checkDataNodeContainer(); checkArgument(nextSchema instanceof YangModeledAnyXmlSchemaNode, "Schema of this node should be instance of YangModeledAnyXmlSchemaNode"); final DataContainerNodeAttrBuilder<NodeIdentifier, YangModeledAnyXmlNode> builder = UNKNOWN_SIZE == childSizeHint ? ImmutableYangModeledAnyXmlNodeBuilder.create((YangModeledAnyXmlSchemaNode) nextSchema) : ImmutableYangModeledAnyXmlNodeBuilder.create( (YangModeledAnyXmlSchemaNode) nextSchema, childSizeHint); enter(builder.withNodeIdentifier(name)); }
@Override public void startMapEntryNode(YangInstanceIdentifier.NodeIdentifierWithPredicates nodeIdentifierWithPredicates, int i) throws IOException, IllegalArgumentException { checkNotSealed(); addBuilder(Builders.mapEntryBuilder().withNodeIdentifier(nodeIdentifierWithPredicates), nodeIdentifierWithPredicates); }
@Override public void startUnkeyedListItem(final NodeIdentifier name, final int childSizeHint) { checkArgument(getCurrent() instanceof NormalizedNodeResultBuilder || getCurrent() instanceof ImmutableUnkeyedListNodeBuilder); final DataContainerNodeAttrBuilder<NodeIdentifier, UnkeyedListEntryNode> builder = UNKNOWN_SIZE == childSizeHint ? ImmutableUnkeyedListEntryNodeBuilder.create() : ImmutableUnkeyedListEntryNodeBuilder.create(childSizeHint); enter(builder.withNodeIdentifier(name)); }
/** * Filter out all non-transitive attributes. * * @param attributes Input attributes * @return Output attributes, transitive only. */ ContainerNode transitiveAttributes(final ContainerNode attributes) { final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> b = Builders.containerBuilder(); b.withNodeIdentifier(attributes.getIdentifier()); final boolean modified = spliceTransitives(b, attributes); return modified ? b.build() : attributes; }
private DataContainerChild<?, ?> processContainerNode(final NormalizedNode<?, ?> node, final Integer depth) { final ContainerNode containerNode = (ContainerNode) node; DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> newContainerBuilder = Builders.containerBuilder() .withNodeIdentifier(containerNode.getIdentifier()); if (depth > 1) { processDataContainerChild((DataContainerNode<?>) node, depth, newContainerBuilder); } return newContainerBuilder.build(); }
/** * Creates a container node for CreateSubscription RPC output. * * @param sid * @return containerNode for Create Subscription Output */ private ContainerNode createCSOutPut(String sid) { final ContainerNode cn = Builders.containerBuilder().withNodeIdentifier(I_PUSH_CS_OUTPUT) .withChild(ImmutableNodes.leafNode(I_PUSH_SUB_ID, sid)).build(); return cn; }
@Override public void startMapEntryNode(final NodeIdentifierWithPredicates identifier, final int childSizeHint) { if (!(getCurrent() instanceof NormalizedNodeResultBuilder)) { checkArgument(getCurrent() instanceof ImmutableMapNodeBuilder || getCurrent() instanceof ImmutableOrderedMapNodeBuilder); } final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder = UNKNOWN_SIZE == childSizeHint ? ImmutableMapEntryNodeBuilder.create() : ImmutableMapEntryNodeBuilder.create(childSizeHint); enter(builder.withNodeIdentifier(identifier)); }
@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); }
static ContainerNode entityOwnersWithEntityTypeEntry(MapEntryNode entityTypeNode) { return ImmutableContainerNodeBuilder.create().withNodeIdentifier( ENTITY_OWNERS_NODE_ID).addChild(ImmutableNodes.mapNodeBuilder(EntityType.QNAME). addChild(entityTypeNode).build()).build(); }
private void publishNotification(final DOMNotification notification, TopicId topicId) { final ContainerNode topicNotification = Builders.containerBuilder().withNodeIdentifier(TOPIC_NOTIFICATION_ARG) .withChild(ImmutableNodes.leafNode(TOPIC_ID_ARG, topicId)) .withChild(ImmutableNodes.leafNode(EVENT_SOURCE_ARG, mount.getNodeId())).withChild(encapsulate(notification)) .build(); try { domPublish.putNotification(new TopicDOMNotification(topicNotification)); } catch (final InterruptedException e) { throw Throwables.propagate(e); } }
private ContainerNode createStats(final Stat stat, final Timestamp timestamp) { final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> builder = Builders.containerBuilder().withNodeIdentifier(new NodeIdentifier(Stats.QNAME)); builder.withChild(ImmutableNodes.leafNode(PEER_STATS_TIMESTAMP_QNAME, timestamp.getValue())); final Tlvs tlvs = stat.getTlvs(); if (tlvs != null) { statsForTlvs(tlvs, builder); } return builder.build(); }
public static DataContainerChild<?, ?> getSourceNode(final QName datastore) { return Builders.containerBuilder().withNodeIdentifier(toId(NETCONF_SOURCE_QNAME)) .withChild( Builders.choiceBuilder().withNodeIdentifier(toId(ConfigSource.QNAME)).withChild( Builders.leafBuilder().withNodeIdentifier(toId(datastore)).build()).build() ).build(); }
public static DataContainerChild<?, ?> getTargetNode(final QName datastore) { return Builders.containerBuilder().withNodeIdentifier(toId(NETCONF_TARGET_QNAME)) .withChild( Builders.choiceBuilder().withNodeIdentifier(toId(ConfigTarget.QNAME)).withChild( Builders.leafBuilder().withNodeIdentifier(toId(datastore)).build()).build() ).build(); }
private ContainerNode createMirrors(final Mirror mirror, final Timestamp timestamp) { final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> builder = Builders.containerBuilder().withNodeIdentifier(new NodeIdentifier(Mirrors.QNAME)); builder.withChild(ImmutableNodes.leafNode(PEER_MIRROR_INFORMATION_QNAME, toDom(MirrorInformationCode.forValue( mirror.getTlvs().getMirrorInformationTlv().getCode().getIntValue())))); builder.withChild(ImmutableNodes.leafNode(PEER_MIRROR_TIMESTAMP_QNAME, timestamp.getValue())); return builder.build(); }