import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; //导入依赖的package包/类
private void notifyAllListeners() {
    searchForEntities((entityTypeNode, entityNode) -> {
        Optional<DataContainerChild<?, ?>> possibleType = entityTypeNode.getChild(ENTITY_TYPE_NODE_ID);
        if (possibleType.isPresent()) {
            final boolean hasOwner;
            final boolean isOwner;

            Optional<DataContainerChild<?, ?>> possibleOwner = entityNode.getChild(ENTITY_OWNER_NODE_ID);
            if (possibleOwner.isPresent()) {
                isOwner = localMemberName.getName().equals(possibleOwner.get().getValue().toString());
                hasOwner = true;
            } else {
                isOwner = false;
                hasOwner = false;
            }

            DOMEntity entity = new DOMEntity(possibleType.get().getValue().toString(),
                (YangInstanceIdentifier) entityNode.getChild(ENTITY_ID_NODE_ID).get().getValue());

            listenerSupport.notifyEntityOwnershipListeners(entity, isOwner, isOwner, hasOwner);
        }
    });
}
 

import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; //导入依赖的package包/类
private void searchForEntities(final EntityWalker walker) {
    Optional<NormalizedNode<?, ?>> possibleEntityTypes = getDataStore().readNode(ENTITY_TYPES_PATH);
    if (!possibleEntityTypes.isPresent()) {
        return;
    }

    for (MapEntryNode entityType:  ((MapNode) possibleEntityTypes.get()).getValue()) {
        Optional<DataContainerChild<?, ?>> possibleEntities = entityType.getChild(ENTITY_NODE_ID);
        if (!possibleEntities.isPresent()) {
            // shouldn't happen but handle anyway
            continue;
        }

        for (MapEntryNode entity:  ((MapNode) possibleEntities.get()).getValue()) {
            walker.onEntity(entityType, entity);
        }
    }
}
 

import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; //导入依赖的package包/类
protected MapEntryNode getMapEntryNodeChild(DataContainerNode<? extends PathArgument> parent, QName childMap,
        QName child, Object key, boolean expectPresent) {
    Optional<DataContainerChild<? extends PathArgument, ?>> childNode =
            parent.getChild(new NodeIdentifier(childMap));
    assertEquals("Missing " + childMap.toString(), true, childNode.isPresent());

    MapNode entityTypeMapNode = (MapNode) childNode.get();
    Optional<MapEntryNode> entityTypeEntry = entityTypeMapNode.getChild(new NodeIdentifierWithPredicates(
            childMap, child, key));
    if (expectPresent && !entityTypeEntry.isPresent()) {
        fail("Missing " + childMap.toString() + " entry for " + key + ". Actual: " + entityTypeMapNode.getValue());
    } else if (!expectPresent && entityTypeEntry.isPresent()) {
        fail("Found unexpected " + childMap.toString() + " entry for " + key);
    }

    return entityTypeEntry.isPresent() ? entityTypeEntry.get() : null;
}
 

import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; //导入依赖的package包/类
@Test
public void testMergeWithInvalidChildNodeNames() throws DataValidationFailedException {
    ContainerNode augContainer = ImmutableContainerNodeBuilder.create().withNodeIdentifier(
            new YangInstanceIdentifier.NodeIdentifier(AUG_CONTAINER)).withChild(
                    ImmutableNodes.containerNode(AUG_INNER_CONTAINER)).build();

    DataContainerChild<?, ?> outerNode = outerNode(outerNodeEntry(1, innerNode("one", "two")));
    ContainerNode normalizedNode = ImmutableContainerNodeBuilder.create()
            .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME)).withChild(outerNode)
            .withChild(augContainer).withChild(ImmutableNodes.leafNode(AUG_QNAME, "aug")).build();

    YangInstanceIdentifier path = TestModel.TEST_PATH;

    pruningDataTreeModification.merge(path, normalizedNode);

    dataTree.commit(getCandidate());

    ContainerNode prunedNode = ImmutableContainerNodeBuilder.create().withNodeIdentifier(
            new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME)).withChild(outerNode).build();

    Optional<NormalizedNode<?, ?>> actual = dataTree.takeSnapshot().readNode(path);
    assertEquals("After pruning present", true, actual.isPresent());
    assertEquals("After pruning", prunedNode, actual.get());
}
 

import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; //导入依赖的package包/类
@Test
public void testWriteWithInvalidChildNodeNames() throws DataValidationFailedException {
    ContainerNode augContainer = ImmutableContainerNodeBuilder.create().withNodeIdentifier(
            new YangInstanceIdentifier.NodeIdentifier(AUG_CONTAINER)).withChild(
                    ImmutableNodes.containerNode(AUG_INNER_CONTAINER)).build();

    DataContainerChild<?, ?> outerNode = outerNode(outerNodeEntry(1, innerNode("one", "two")));
    ContainerNode normalizedNode = ImmutableContainerNodeBuilder.create()
            .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME)).withChild(outerNode)
            .withChild(augContainer).withChild(ImmutableNodes.leafNode(AUG_QNAME, "aug"))
            .withChild(ImmutableNodes.leafNode(NAME_QNAME, "name")).build();

    YangInstanceIdentifier path = TestModel.TEST_PATH;

    pruningDataTreeModification.write(path, normalizedNode);

    dataTree.commit(getCandidate());

    ContainerNode prunedNode = ImmutableContainerNodeBuilder.create()
            .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME)).withChild(outerNode)
            .withChild(ImmutableNodes.leafNode(NAME_QNAME, "name")).build();

    Optional<NormalizedNode<?, ?>> actual = dataTree.takeSnapshot().readNode(path);
    assertEquals("After pruning present", true, actual.isPresent());
    assertEquals("After pruning", prunedNode, actual.get());
}
 

import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; //导入依赖的package包/类
private void navigateDataContainerNode(int level, final String parentPath,
        final DataContainerNode<?> dataContainerNode) {
    visitor.visitNode(level, parentPath, dataContainerNode);

    String newParentPath = parentPath + "/" + dataContainerNode.getIdentifier().toString();

    final Iterable<DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?>> value = dataContainerNode
            .getValue();
    for (NormalizedNode<?, ?> node : value) {
        if (node instanceof MixinNode && node instanceof NormalizedNodeContainer) {
            navigateNormalizedNodeContainerMixin(level, newParentPath, (NormalizedNodeContainer<?, ?, ?>) node);
        } else {
            navigateNormalizedNode(level, newParentPath, node);
        }
    }

}
 

import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; //导入依赖的package包/类
private static List<ProtocolIps> createProtocolsIps(final UnkeyedListNode protocolIpsData) {
    final List<ProtocolIps> protocolIps = new ArrayList<>();

    for (final UnkeyedListEntryNode node : protocolIpsData.getValue()) {
        final ProtocolIpsBuilder ipsBuilder = new ProtocolIpsBuilder();
        final Optional<DataContainerChild<? extends PathArgument, ?>> opValue = node.getChild(AbstractFlowspecNlriParser.OP_NID);
        if (opValue.isPresent()) {
            ipsBuilder.setOp(NumericOneByteOperandParser.INSTANCE.create((Set<String>) opValue.get().getValue()));
        }
        final Optional<DataContainerChild<? extends PathArgument, ?>> valueNode = node.getChild(AbstractFlowspecNlriParser.VALUE_NID);
        if (valueNode.isPresent()) {
            ipsBuilder.setValue((Short) valueNode.get().getValue());
        }
        protocolIps.add(ipsBuilder.build());
    }

    return protocolIps;
}
 

import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; //导入依赖的package包/类
public final List<Flowspec> extractFlowspec(final DataContainerNode<?> route) {
    requireNonNull(route, "Cannot extract flowspec from null route.");
    final List<Flowspec> fsList = new ArrayList<>();
    final Optional<DataContainerChild<? extends PathArgument, ?>> flowspecs = route.getChild(FLOWSPEC_NID);
    if (flowspecs.isPresent()) {
        for (final UnkeyedListEntryNode flowspec : ((UnkeyedListNode) flowspecs.get()).getValue()) {
            final FlowspecBuilder fsBuilder = new FlowspecBuilder();
            final Optional<DataContainerChild<?, ?>> flowspecType = flowspec.getChild(FLOWSPEC_TYPE_NID);
            if (flowspecType.isPresent()) {
                final ChoiceNode fsType = (ChoiceNode) flowspecType.get();
                processFlowspecType(fsType, fsBuilder);
            }
            fsList.add(fsBuilder.build());
        }
    }
    return fsList;
}
 

import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; //导入依赖的package包/类
private static List<Ports> createPorts(final UnkeyedListNode portsData) {
    final List<Ports> ports = new ArrayList<>();

    for (final UnkeyedListEntryNode node : portsData.getValue()) {
        final PortsBuilder portsBuilder = new PortsBuilder();
        final Optional<DataContainerChild<? extends PathArgument, ?>> opValue = node.getChild(OP_NID);
        if (opValue.isPresent()) {
            portsBuilder.setOp(NumericTwoByteOperandParser.INSTANCE.create((Set<String>) opValue.get().getValue()));
        }
        final Optional<DataContainerChild<? extends PathArgument, ?>> valueNode = node.getChild(VALUE_NID);
        if (valueNode.isPresent()) {
            portsBuilder.setValue((Integer) valueNode.get().getValue());
        }
        ports.add(portsBuilder.build());
    }

    return ports;
}
 

import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; //导入依赖的package包/类
private static List<DestinationPorts> createDestinationPorts(final UnkeyedListNode destinationPortsData) {
    final List<DestinationPorts> destinationPorts = new ArrayList<>();

    for (final UnkeyedListEntryNode node : destinationPortsData.getValue()) {
        final DestinationPortsBuilder destPortsBuilder = new DestinationPortsBuilder();
        final Optional<DataContainerChild<? extends PathArgument, ?>> opValue = node.getChild(OP_NID);
        if (opValue.isPresent()) {
            destPortsBuilder.setOp(NumericTwoByteOperandParser.INSTANCE.create((Set<String>) opValue.get().getValue()));
        }
        final Optional<DataContainerChild<? extends PathArgument, ?>> valueNode = node.getChild(VALUE_NID);
        if (valueNode.isPresent()) {
            destPortsBuilder.setValue((Integer) valueNode.get().getValue());
        }
        destinationPorts.add(destPortsBuilder.build());
    }

    return destinationPorts;
}
 

import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; //导入依赖的package包/类
private static List<SourcePorts> createSourcePorts(final UnkeyedListNode sourcePortsData) {
    final List<SourcePorts> sourcePorts = new ArrayList<>();

    for (final UnkeyedListEntryNode node : sourcePortsData.getValue()) {
        final SourcePortsBuilder sourcePortsBuilder = new SourcePortsBuilder();
        final Optional<DataContainerChild<? extends PathArgument, ?>> opValue = node.getChild(OP_NID);
        if (opValue.isPresent()) {
            sourcePortsBuilder.setOp(NumericTwoByteOperandParser.INSTANCE.create((Set<String>) opValue.get().getValue()));
        }
        final Optional<DataContainerChild<? extends PathArgument, ?>> valueNode = node.getChild(VALUE_NID);
        if (valueNode.isPresent()) {
            sourcePortsBuilder.setValue((Integer) valueNode.get().getValue());
        }
        sourcePorts.add(sourcePortsBuilder.build());
    }

    return sourcePorts;
}
 

import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; //导入依赖的package包/类
private static List<Types> createTypes(final UnkeyedListNode typesData) {
    final List<Types> types = new ArrayList<>();

    for (final UnkeyedListEntryNode node : typesData.getValue()) {
        final TypesBuilder typesBuilder = new TypesBuilder();
        final Optional<DataContainerChild<? extends PathArgument, ?>> opValue = node.getChild(OP_NID);
        if (opValue.isPresent()) {
            typesBuilder.setOp(NumericOneByteOperandParser.INSTANCE.create((Set<String>) opValue.get().getValue()));
        }
        final Optional<DataContainerChild<? extends PathArgument, ?>> valueNode = node.getChild(VALUE_NID);
        if (valueNode.isPresent()) {
            typesBuilder.setValue((Short) valueNode.get().getValue());
        }
        types.add(typesBuilder.build());
    }

    return types;
}
 

import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; //导入依赖的package包/类
private static List<Codes> createCodes(final UnkeyedListNode codesData) {
    final List<Codes> codes = new ArrayList<>();

    for (final UnkeyedListEntryNode node : codesData.getValue()) {
        final CodesBuilder codesBuilder = new CodesBuilder();
        final Optional<DataContainerChild<? extends PathArgument, ?>> opValue = node.getChild(OP_NID);
        if (opValue.isPresent()) {
            codesBuilder.setOp(NumericOneByteOperandParser.INSTANCE.create((Set<String>) opValue.get().getValue()));
        }
        final Optional<DataContainerChild<? extends PathArgument, ?>> valueNode = node.getChild(VALUE_NID);
        if (valueNode.isPresent()) {
            codesBuilder.setValue((Short) valueNode.get().getValue());
        }
        codes.add(codesBuilder.build());
    }

    return codes;
}
 

import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; //导入依赖的package包/类
private static List<TcpFlags> createTcpFlags(final UnkeyedListNode tcpFlagsData) {
    final List<TcpFlags> tcpFlags = new ArrayList<>();

    for (final UnkeyedListEntryNode node : tcpFlagsData.getValue()) {
        final TcpFlagsBuilder tcpFlagsBuilder = new TcpFlagsBuilder();
        final Optional<DataContainerChild<? extends PathArgument, ?>> opValue = node.getChild(OP_NID);
        if (opValue.isPresent()) {
            tcpFlagsBuilder.setOp(BitmaskOperandParser.INSTANCE.create((Set<String>) opValue.get().getValue()));
        }
        final Optional<DataContainerChild<? extends PathArgument, ?>> valueNode = node.getChild(VALUE_NID);
        if (valueNode.isPresent()) {
            tcpFlagsBuilder.setValue((Integer) valueNode.get().getValue());
        }
        tcpFlags.add(tcpFlagsBuilder.build());
    }

    return tcpFlags;
}
 

import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; //导入依赖的package包/类
private static List<Dscps> createDscpsLengths(final UnkeyedListNode dscpLengthsData) {
    final List<Dscps> dscpsLengths = new ArrayList<>();

    for (final UnkeyedListEntryNode node : dscpLengthsData.getValue()) {
        final DscpsBuilder dscpsLengthsBuilder = new DscpsBuilder();
        final Optional<DataContainerChild<? extends PathArgument, ?>> opValue = node.getChild(OP_NID);
        if (opValue.isPresent()) {
            dscpsLengthsBuilder.setOp(NumericOneByteOperandParser.INSTANCE.create((Set<String>) opValue.get().getValue()));
        }
        final Optional<DataContainerChild<? extends PathArgument, ?>> valueNode = node.getChild(VALUE_NID);
        if (valueNode.isPresent()) {
            dscpsLengthsBuilder.setValue(new Dscp((Short) valueNode.get().getValue()));
        }
        dscpsLengths.add(dscpsLengthsBuilder.build());
    }

    return dscpsLengths;
}
 

import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; //导入依赖的package包/类
@Override
protected final void processDestination(
    final DOMDataWriteTransaction tx,
    final YangInstanceIdentifier routesPath,
    final ContainerNode destination,
    final ContainerNode attributes,
    final ApplyRoute function
) {
    if (destination != null) {
        final YangInstanceIdentifier base = routesPath.node(routesContainerIdentifier()).node(routeQName());
        final Optional<DataContainerChild<? extends PathArgument, ?>> maybePathIdLeaf = destination.getChild(routePathIdNid());
        final String routeKeyValue = this.nlriParser.stringNlri(destination);
        final NodeIdentifierWithPredicates routeKey = PathIdUtil.createNidKey(routeQName(), routeKeyQName(), pathIdQName(), routeKeyValue, maybePathIdLeaf);
        function.apply(tx, base, routeKey, destination, attributes);
    }
}
 

import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; //导入依赖的package包/类
private static List<NextHeaders> createNextHeaders(final UnkeyedListNode nextHeadersData) {
    final List<NextHeaders> nextHeaders = new ArrayList<>();

    for (final UnkeyedListEntryNode node : nextHeadersData.getValue()) {
        final NextHeadersBuilder nextHeadersBuilder = new NextHeadersBuilder();
        final Optional<DataContainerChild<? extends PathArgument, ?>> opValue = node.getChild(AbstractFlowspecNlriParser.OP_NID);
        if (opValue.isPresent()) {
            nextHeadersBuilder.setOp(NumericOneByteOperandParser.INSTANCE.create((Set<String>) opValue.get().getValue()));
        }
        final Optional<DataContainerChild<? extends PathArgument, ?>> valueNode = node.getChild(AbstractFlowspecNlriParser.VALUE_NID);
        if (valueNode.isPresent()) {
            nextHeadersBuilder.setValue((Short) valueNode.get().getValue());
        }
        nextHeaders.add(nextHeadersBuilder.build());
    }

    return nextHeaders;
}
 

import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; //导入依赖的package包/类
private static List<FlowLabel> createFlowLabels(final UnkeyedListNode flowLabelsData) {
    final List<FlowLabel> flowLabels = new ArrayList<>();

    for (final UnkeyedListEntryNode node : flowLabelsData.getValue()) {
        final FlowLabelBuilder flowLabelsBuilder = new FlowLabelBuilder();
        final Optional<DataContainerChild<? extends PathArgument, ?>> opValue = node.getChild(AbstractFlowspecNlriParser.OP_NID);
        if (opValue.isPresent()) {
            flowLabelsBuilder.setOp(NumericOneByteOperandParser.INSTANCE.create((Set<String>) opValue.get().getValue()));
        }
        final Optional<DataContainerChild<? extends PathArgument, ?>> valueNode = node.getChild(AbstractFlowspecNlriParser.VALUE_NID);
        if (valueNode.isPresent()) {
            flowLabelsBuilder.setValue((Long) valueNode.get().getValue());
        }
        flowLabels.add(flowLabelsBuilder.build());
    }

    return flowLabels;
}
 

import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; //导入依赖的package包/类
private static void serializeLocalNodeDescriptor(final CLinkstateDestinationBuilder builder, final ChoiceNode objectType) {
    // link local node descriptors
    final LinkCaseBuilder linkBuilder = new LinkCaseBuilder();

    linkBuilder.setLocalNodeDescriptors(NodeNlriParser.serializeLocalNodeDescriptors((ContainerNode) objectType.getChild(LOCAL_NODE_DESCRIPTORS_NID).get()));
    // link remote node descriptors
    if (objectType.getChild(REMOTE_NODE_DESCRIPTORS_NID).isPresent()) {
        linkBuilder.setRemoteNodeDescriptors(NodeNlriParser.serializeRemoteNodeDescriptors((ContainerNode) objectType.getChild(REMOTE_NODE_DESCRIPTORS_NID).get()));
    }
    // link descriptors
    final Optional<DataContainerChild<? extends PathArgument, ?>> linkDescriptors = objectType.getChild(LINK_DESCRIPTORS_NID);
    if (linkDescriptors.isPresent()) {
        linkBuilder.setLinkDescriptors(LinkNlriParser.serializeLinkDescriptors((ContainerNode) linkDescriptors.get()));
    }
    builder.setObjectType(linkBuilder.build());
}
 

import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; //导入依赖的package包/类
private static void serializeCommonParts(final CLinkstateDestinationBuilder builder, final DataContainerNode<? extends PathArgument> linkstate) {
    // serialize common parts
    final Optional<DataContainerChild<? extends PathArgument, ?>> distinguisher = linkstate.getChild(DISTINGUISHER_NID);
    if (distinguisher.isPresent()) {
        builder.setDistinguisher(new RouteDistinguisher((BigInteger) distinguisher.get().getValue()));
    }
    final Optional<DataContainerChild<? extends PathArgument, ?>> protocolId = linkstate.getChild(PROTOCOL_ID_NID);
    // DOM representation contains values as are in the model, not as are in generated enum
    if (protocolId.isPresent()) {
        builder.setProtocolId(ProtocolId.forValue(domProtocolIdValue((String) protocolId.get().getValue())));
    }
    final Optional<DataContainerChild<? extends PathArgument, ?>> identifier = linkstate.getChild(IDENTIFIER_NID);
    if (identifier.isPresent()) {
        builder.setIdentifier(new Identifier((BigInteger) identifier.get().getValue()));
    }
}