Java Module.getDataChildByName方法代码示例

import org.opendaylight.yangtools.yang.model.api.Module; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
public T createDefaultInstance(final FallbackConfigProvider fallback) throws ConfigXMLReaderException,
        URISyntaxException, ParserConfigurationException, XMLStreamException, SAXException, IOException {
    YangInstanceIdentifier yangPath = bindingSerializer.toYangInstanceIdentifier(bindingContext.appConfigPath);

    LOG.debug("{}: Creating app config instance from path {}, Qname: {}", logName, yangPath,
            bindingContext.bindingQName);

    checkNotNull(schemaService, "%s: Could not obtain the SchemaService OSGi service", logName);

    SchemaContext schemaContext = schemaService.getGlobalContext();

    Module module = schemaContext.findModuleByNamespaceAndRevision(bindingContext.bindingQName.getNamespace(),
            bindingContext.bindingQName.getRevision());
    checkNotNull(module, "%s: Could not obtain the module schema for namespace %s, revision %s",
            logName, bindingContext.bindingQName.getNamespace(), bindingContext.bindingQName.getRevision());

    DataSchemaNode dataSchema = module.getDataChildByName(bindingContext.bindingQName);
    checkNotNull(dataSchema, "%s: Could not obtain the schema for %s", logName, bindingContext.bindingQName);

    checkCondition(bindingContext.schemaType.isAssignableFrom(dataSchema.getClass()),
            "%s: Expected schema type %s for %s but actual type is %s", logName,
            bindingContext.schemaType, bindingContext.bindingQName, dataSchema.getClass());

    NormalizedNode<?, ?> dataNode = parsePossibleDefaultAppConfigXMLFile(schemaContext, dataSchema);
    if (dataNode == null) {
        dataNode = fallback.get(schemaService.getGlobalContext(), dataSchema);
    }

    DataObject appConfig = bindingSerializer.fromNormalizedNode(yangPath, dataNode).getValue();

    // This shouldn't happen but need to handle it in case...
    checkNotNull(appConfig, "%s: Could not create instance for app config binding %s", logName,
            bindingContext.appConfigBindingClass);

    return (T) appConfig;
}
 

import org.opendaylight.yangtools.yang.model.api.Module; //导入方法依赖的package包/类
@Test
public void testYangDataBeingIgnored() throws Exception {
    // yang-data statement is ignored if it does not appear as a top-level statement
    // i.e., it will not appear in the final SchemaContext
    final SchemaContext schemaContext = reactor.newBuild().addSources(BAR_MODULE, IETF_RESTCONF_MODULE)
            .buildEffective();
    assertNotNull(schemaContext);

    final Module bar = schemaContext.findModule("bar", REVISION).get();
    final ContainerSchemaNode cont = (ContainerSchemaNode) bar.getDataChildByName(
            QName.create(bar.getQNameModule(), "cont"));
    assertNotNull(cont);

    final Set<ExtensionDefinition> extensions = schemaContext.getExtensions();
    assertEquals(1, extensions.size());

    final List<UnknownSchemaNode> unknownSchemaNodes = cont.getUnknownSchemaNodes();
    assertEquals(0, unknownSchemaNodes.size());
}
 

import org.opendaylight.yangtools.yang.model.api.Module; //导入方法依赖的package包/类
@Test
public void testAugmentInUsesResolving() throws Exception {
    final SchemaContext context = TestUtils.loadModules(getClass().getResource("/augment-test/augment-in-uses")
        .toURI());
    assertEquals(1, context.getModules().size());

    final Module test = context.getModules().iterator().next();
    final DataNodeContainer links = (DataNodeContainer) test.getDataChildByName(QName.create(test.getQNameModule(),
            "links"));
    final DataNodeContainer link = (DataNodeContainer) links.getDataChildByName(QName.create(test.getQNameModule(),
            "link"));
    final DataNodeContainer nodes = (DataNodeContainer) link.getDataChildByName(QName.create(test.getQNameModule(),
            "nodes"));
    final ContainerSchemaNode node = (ContainerSchemaNode) nodes.getDataChildByName(QName.create(
            test.getQNameModule(), "node"));
    final Set<AugmentationSchemaNode> augments = node.getAvailableAugmentations();
    assertEquals(1, augments.size());
    assertEquals(1, node.getChildNodes().size());
    final LeafSchemaNode id = (LeafSchemaNode) node.getDataChildByName(QName.create(test.getQNameModule(), "id"));
    assertTrue(id.isAugmenting());
}
 

import org.opendaylight.yangtools.yang.model.api.Module; //导入方法依赖的package包/类
@Test
public void testInstanceIdentifier2() {
    Module tested = TestUtils.findModule(context, "custom-types-test").get();
    LeafSchemaNode leaf = (LeafSchemaNode) tested.getDataChildByName(
            QName.create(tested.getQNameModule(), "inst-id-leaf2"));
    InstanceIdentifierTypeDefinition leafType = (InstanceIdentifierTypeDefinition) leaf.getType();
    assertFalse(leafType.requireInstance());
}
 

import org.opendaylight.yangtools.yang.model.api.Module; //导入方法依赖的package包/类
@Test
public void testStringPatternCheckingCodec() {
    final SchemaContext schemaContext = YangParserTestUtils.parseYangResource(
        "/string-pattern-checking-codec-test.yang");
    assertNotNull(schemaContext);

    final QNameModule testModuleQName = QNameModule.create(URI.create("string-pattern-checking-codec-test"));

    final Module testModule = schemaContext.findModules("string-pattern-checking-codec-test").iterator().next();
    final ContainerSchemaNode testContainer = (ContainerSchemaNode) testModule.getDataChildByName(
            QName.create(testModuleQName, "test-container"));
    assertNotNull(testContainer);

    final LeafSchemaNode testLeaf = (LeafSchemaNode) testContainer.getDataChildByName(
            QName.create(testModuleQName, "string-leaf-with-valid-pattern"));
    assertNotNull(testLeaf);

    final StringCodec<String> codec = getCodec(testLeaf.getType(), StringCodec.class);
    assertNotNull(codec);
    assertEquals("ABCD", codec.serialize("ABCD"));
    assertEquals("ABCD", codec.deserialize("ABCD"));

    try {
        codec.deserialize("abcd");
        fail("Exception should have been thrown.");
    } catch (final IllegalArgumentException ex) {
        LOG.debug("IllegalArgumentException was thrown as expected", ex);
        assertEquals("Supplied value does not match the regular expression ^[A-Z]+$.", ex.getMessage());
    }
}
 

import org.opendaylight.yangtools.yang.model.api.Module; //导入方法依赖的package包/类
@Before
public void setup() throws URISyntaxException {
    final File leafRefTestYang = new File(getClass().getResource("/builder-test/immutable-ordered-map-node.yang")
            .toURI());
    final SchemaContext schema = YangParserTestUtils.parseYangFiles(leafRefTestYang);
    final Module module = schema.getModules().iterator().next();
    final DataSchemaNode root = module.getDataChildByName(ROOT_CONTAINER);
    list = (ListSchemaNode)((ContainerSchemaNode) root).getDataChildByName(LIST_MAIN);
    leafList = (LeafListSchemaNode)((ContainerSchemaNode) root).getDataChildByName(LEAF_LIST_MAIN);
}
 

import org.opendaylight.yangtools.yang.model.api.Module; //导入方法依赖的package包/类
@Test
public void testInstanceIdentifier1() {
    Module tested = TestUtils.findModule(context, "custom-types-test").get();
    LeafSchemaNode leaf = (LeafSchemaNode) tested.getDataChildByName(
            QName.create(tested.getQNameModule(), "inst-id-leaf1"));
    InstanceIdentifierTypeDefinition leafType = (InstanceIdentifierTypeDefinition) leaf.getType();
    assertFalse(leafType.requireInstance());
    assertEquals(1, leaf.getUnknownSchemaNodes().size());
}
 

import org.opendaylight.yangtools.yang.model.api.Module; //导入方法依赖的package包/类
@Test
public void testStrictParsing() throws Exception {
    // should fail because strictParsing is switched on and the top-level-container node contains child nodes
    // which are not defined in the provided YANG model
    final SchemaContext schemaContext = YangParserTestUtils.parseYangResource(
            "/strict-parsing-mode-test/foo.yang");
    final Module fooModule = schemaContext.getModules().iterator().next();
    final ContainerSchemaNode topLevelContainer = (ContainerSchemaNode) fooModule.getDataChildByName(
            QName.create(fooModule.getQNameModule(), "top-level-container"));

    final InputStream resourceAsStream = StrictParsingModeTest.class.getResourceAsStream(
            "/strict-parsing-mode-test/foo.xml");

    final XMLInputFactory factory = XMLInputFactory.newInstance();
    final XMLStreamReader reader = factory.createXMLStreamReader(resourceAsStream);

    final NormalizedNodeResult result = new NormalizedNodeResult();
    final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);

    final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, topLevelContainer, true);
    try {
        xmlParser.parse(reader);
        fail("IllegalStateException should have been thrown because of an unknown child node.");
    } catch (IllegalStateException ex) {
        assertEquals("Schema for node with name unknown-container-a and namespace foo doesn't exist at "
                + "AbsoluteSchemaPath{path=[(foo)top-level-container]}", ex.getMessage());
    }
}
 

import org.opendaylight.yangtools.yang.model.api.Module; //导入方法依赖的package包/类
@Test
public void testSharedSchemaRepositoryWithNoFeaturesSupported() throws Exception {
    final Set<QName> supportedFeatures = ImmutableSet.of();

    final SharedSchemaRepository sharedSchemaRepository = new SharedSchemaRepository(
            "shared-schema-repo-with-features-test");

    final SettableSchemaProvider<ASTSchemaSource> foobar = getImmediateYangSourceProviderFromResource(
        "/if-feature-resolution-test/shared-schema-repository/foobar.yang");
    foobar.register(sharedSchemaRepository);
    foobar.setResult();

    final SchemaContextFactory fact = sharedSchemaRepository
            .createSchemaContextFactory(SchemaSourceFilter.ALWAYS_ACCEPT);

    final ListenableFuture<SchemaContext> testSchemaContextFuture =
            fact.createSchemaContext(ImmutableList.of(foobar.getId()), supportedFeatures);
    assertTrue(testSchemaContextFuture.isDone());
    assertSchemaContext(testSchemaContextFuture.get(), 1);

    final Module module = testSchemaContextFuture.get().findModules("foobar").iterator().next();
    assertNotNull(module);
    assertEquals(1, module.getChildNodes().size());

    final ContainerSchemaNode testContainerC = (ContainerSchemaNode) module.getDataChildByName(
            QName.create(module.getQNameModule(), "test-container-c"));
    assertNotNull(testContainerC);
    final LeafSchemaNode testLeafC = (LeafSchemaNode) testContainerC.getDataChildByName(
            QName.create(module.getQNameModule(), "test-leaf-c"));
    assertNotNull(testLeafC);
}
 

import org.opendaylight.yangtools.yang.model.api.Module; //导入方法依赖的package包/类
@Test
public void testModels() throws Exception {
    final SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug6240/correct");
    assertNotNull(context);

    final Set<Module> modules = context.getModules();
    assertEquals(2, modules.size());

    Module bar = null;
    for (final Module module : modules) {
        if ("bar".equals(module.getName())) {
            bar = module;
            break;
        }
    }

    assertNotNull(bar);
    assertTrue(bar.getDataChildByName(QName.create(NS, REV, "foo-grp-con")) instanceof ContainerSchemaNode);
    assertTrue(bar.getDataChildByName(QName.create(NS, REV, "sub-foo-grp-con")) instanceof ContainerSchemaNode);

    assertEquals(1, bar.getSubmodules().size());

    final DataSchemaNode dataChildByName = bar.getDataChildByName(QName.create(NS, REV, "sub-bar-con"));
    assertTrue(dataChildByName instanceof ContainerSchemaNode);
    final ContainerSchemaNode subBarCon = (ContainerSchemaNode) dataChildByName;

    assertTrue(subBarCon.getDataChildByName(QName.create(NS, REV, "foo-grp-con")) instanceof ContainerSchemaNode);
    assertTrue(subBarCon.getDataChildByName(QName.create(NS, REV, "sub-foo-grp-con"))
        instanceof ContainerSchemaNode);
}
 

import org.opendaylight.yangtools.yang.model.api.Module; //导入方法依赖的package包/类
@Test
public void whenStmtTest() throws ReactorException {
    final SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
            .addSource(sourceForResource("/must-when-stmt-test/when-test.yang"))
            .buildEffective();
    assertNotNull(result);

    final Module testModule = result.findModules("when-test").iterator().next();
    assertNotNull(testModule);

    final ContainerSchemaNode container = (ContainerSchemaNode) testModule.getDataChildByName(
        QName.create(testModule.getQNameModule(), "test-container"));
    assertNotNull(container);
    assertEquals("conditional-leaf = 'autumn-leaf'", container.getWhenCondition().get().toString());
}
 

import org.opendaylight.yangtools.yang.model.api.Module; //导入方法依赖的package包/类
@Test
public void testDeclaredContainer() throws ReactorException {
    final StatementStreamSource containerStmtModule =
            sourceForResource("/declared-statements-test/container-declared-test.yang");

    final SchemaContext schemaContext = StmtTestUtils.parseYangSources(containerStmtModule);
    assertNotNull(schemaContext);

    final Module testModule = schemaContext.findModules("container-declared-test").iterator().next();
    assertNotNull(testModule);

    final ContainerSchemaNode containerSchemaNode = (ContainerSchemaNode) testModule.getDataChildByName(
            QName.create(testModule.getQNameModule(), "test-container"));
    assertNotNull(containerSchemaNode);
    final ContainerStatement containerStatement =
            ((ContainerEffectiveStatement) containerSchemaNode).getDeclared();

    final QName name = containerStatement.getName();
    assertNotNull(name);

    final WhenStatement containerStatementWhen = containerStatement.getWhenStatement();
    assertNotNull(containerStatementWhen);

    final Collection<? extends IfFeatureStatement> containerStatementIfFeatures =
            containerStatement.getIfFeatures();
    assertNotNull(containerStatementIfFeatures);
    assertEquals(1, containerStatementIfFeatures.size());

    final Collection<? extends MustStatement> containerStatementMusts = containerStatement.getMusts();
    assertNotNull(containerStatementMusts);
    assertEquals(1, containerStatementMusts.size());

    final PresenceStatement containerStatementPresence = containerStatement.getPresence();
    assertNotNull(containerStatementPresence);
    assertNotNull(containerStatementPresence.getValue());

    final ConfigStatement containerStatementConfig = containerStatement.getConfig();
    assertNotNull(containerStatementConfig);

    final StatusStatement containerStatementStatus = containerStatement.getStatus();
    assertNotNull(containerStatementStatus);

    final DescriptionStatement containerStatementDescription = containerStatement.getDescription();
    assertNotNull(containerStatementDescription);

    final ReferenceStatement containerStatementReference = containerStatement.getReference();
    assertNotNull(containerStatementReference);

    final Collection<? extends TypedefStatement> containerStatementTypedefs = containerStatement.getTypedefs();
    assertNotNull(containerStatementTypedefs);
    assertEquals(1, containerStatementTypedefs.size());

    final Collection<? extends GroupingStatement> containerStatementGroupings = containerStatement.getGroupings();
    assertNotNull(containerStatementGroupings);
    assertEquals(1, containerStatementGroupings.size());

    final Collection<? extends DataDefinitionStatement> containerStatementDataDefinitions =
            containerStatement.getDataDefinitions();

    assertNotNull(containerStatementDataDefinitions);
    assertEquals(1, containerStatementDataDefinitions.size());
}
 

import org.opendaylight.yangtools.yang.model.api.Module; //导入方法依赖的package包/类
private static SchemaNode findNodeInModule(final Module module, final Iterable<QName> path) {

        Preconditions.checkArgument(module != null, "Parent reference cannot be NULL");
        Preconditions.checkArgument(path != null, "Path reference cannot be NULL");

        if (!path.iterator().hasNext()) {
            LOG.debug("No node matching {} found in node {}", path, module);
            return null;
        }

        final QName current = path.iterator().next();
        LOG.trace("Looking for node {} in module {}", current, module);

        SchemaNode foundNode = null;
        final Iterable<QName> nextPath = nextLevel(path);

        foundNode = module.getDataChildByName(current);
        if (foundNode != null && nextPath.iterator().hasNext()) {
            foundNode = findNodeIn(foundNode, nextPath);
        }

        if (foundNode == null) {
            foundNode = getGroupingByName(module, current);
            if (foundNode != null && nextPath.iterator().hasNext()) {
                foundNode = findNodeIn(foundNode, nextPath);
            }
        }

        if (foundNode == null) {
            foundNode = getRpcByName(module, current);
            if (foundNode != null && nextPath.iterator().hasNext()) {
                foundNode = findNodeIn(foundNode, nextPath);
            }
        }

        if (foundNode == null) {
            foundNode = getNotificationByName(module, current);
            if (foundNode != null && nextPath.iterator().hasNext()) {
                foundNode = findNodeIn(foundNode, nextPath);
            }
        }

        if (foundNode == null) {
            LOG.debug("No node matching {} found in node {}", path, module);
        }

        return foundNode;

    }
 

import org.opendaylight.yangtools.yang.model.api.Module; //导入方法依赖的package包/类
@Test
public void testSharedSchemaRepositoryWithSomeFeaturesSupported() throws Exception {
    final Set<QName> supportedFeatures = ImmutableSet.of(QName.create("foobar-namespace", "test-feature-1"));

    final SharedSchemaRepository sharedSchemaRepository = new SharedSchemaRepository(
            "shared-schema-repo-with-features-test");

    final SettableSchemaProvider<ASTSchemaSource> foobar = getImmediateYangSourceProviderFromResource(
        "/if-feature-resolution-test/shared-schema-repository/foobar.yang");
    foobar.register(sharedSchemaRepository);
    foobar.setResult();

    final SchemaContextFactory fact = sharedSchemaRepository
            .createSchemaContextFactory(SchemaSourceFilter.ALWAYS_ACCEPT);

    final ListenableFuture<SchemaContext> testSchemaContextFuture =
            fact.createSchemaContext(ImmutableList.of(foobar.getId()), supportedFeatures);
    assertTrue(testSchemaContextFuture.isDone());
    assertSchemaContext(testSchemaContextFuture.get(), 1);

    final Module module = testSchemaContextFuture.get().findModules("foobar").iterator().next();
    assertNotNull(module);
    assertEquals(2, module.getChildNodes().size());

    final ContainerSchemaNode testContainerA = (ContainerSchemaNode) module.getDataChildByName(
            QName.create(module.getQNameModule(), "test-container-a"));
    assertNotNull(testContainerA);
    final LeafSchemaNode testLeafA = (LeafSchemaNode) testContainerA.getDataChildByName(
            QName.create(module.getQNameModule(), "test-leaf-a"));
    assertNotNull(testLeafA);

    final ContainerSchemaNode testContainerB = (ContainerSchemaNode) module.getDataChildByName(
            QName.create(module.getQNameModule(), "test-container-b"));
    assertNull(testContainerB);

    final ContainerSchemaNode testContainerC = (ContainerSchemaNode) module.getDataChildByName(
            QName.create(module.getQNameModule(), "test-container-c"));
    assertNotNull(testContainerC);
    final LeafSchemaNode testLeafC = (LeafSchemaNode) testContainerC.getDataChildByName(
            QName.create(module.getQNameModule(), "test-leaf-c"));
    assertNotNull(testLeafC);
}
 

import org.opendaylight.yangtools.yang.model.api.Module; //导入方法依赖的package包/类
private static void configModuleTest(final SchemaContext context) {
    final Module configModule = context.findModule("config", Revision.of("2013-04-05")).get();
    final Module module = context.findModule("opendaylight-sal-dom-broker-impl", Revision.of("2013-10-28")).get();

    final DataSchemaNode dataNode = configModule.getDataChildByName(QName.create(configModule.getQNameModule(),
        "modules"));
    assertTrue(dataNode instanceof ContainerSchemaNode);

    final ContainerSchemaNode moduleContainer = (ContainerSchemaNode) dataNode;
    final DataSchemaNode dataChildList = moduleContainer
            .getDataChildByName(QName.create(configModule.getQNameModule(), "module"));

    assertTrue(dataChildList instanceof ListSchemaNode);

    final ListSchemaNode listModule = (ListSchemaNode) dataChildList;
    final DataSchemaNode dataChildChoice = listModule
            .getDataChildByName(QName.create(configModule.getQNameModule(), "configuration"));

    assertTrue(dataChildChoice instanceof ChoiceSchemaNode);

    final ChoiceSchemaNode confChoice = (ChoiceSchemaNode) dataChildChoice;
    final CaseSchemaNode caseNodeByName = confChoice.findCaseNodes("dom-broker-impl").iterator().next();

    assertNotNull(caseNodeByName);
    final DataSchemaNode dataNode2 = caseNodeByName
            .getDataChildByName(QName.create(module.getQNameModule(), "async-data-broker"));
    assertTrue(dataNode2 instanceof ContainerSchemaNode);

    final ContainerSchemaNode containerNode = (ContainerSchemaNode) dataNode2;
    final DataSchemaNode leaf = containerNode.getDataChildByName(QName.create(module.getQNameModule(), "type"));
    final List<UnknownSchemaNode> unknownSchemaNodes = leaf.getUnknownSchemaNodes();

    assertEquals(1, unknownSchemaNodes.size());

    final UnknownSchemaNode unknownSchemaNode = unknownSchemaNodes.get(0);

    assertEquals(unknownSchemaNode.getQName(), unknownSchemaNode.getPath().getLastComponent());
    assertEquals("dom-async-data-broker", unknownSchemaNode.getQName().getLocalName());

    final CaseSchemaNode domInmemoryDataBroker = confChoice.findCaseNodes("dom-inmemory-data-broker").iterator()
            .next();

    assertNotNull(domInmemoryDataBroker);
    final DataSchemaNode schemaService = domInmemoryDataBroker
            .getDataChildByName(QName.create(module.getQNameModule(), "schema-service"));
    assertTrue(schemaService instanceof ContainerSchemaNode);

    final ContainerSchemaNode schemaServiceContainer = (ContainerSchemaNode) schemaService;

    assertEquals(1, schemaServiceContainer.getUses().size());
    final UsesNode uses = schemaServiceContainer.getUses().iterator().next();
    final QName groupingQName = QName.create("urn:opendaylight:params:xml:ns:yang:controller:config", "2013-04-05",
        "service-ref");
    final QName usesGroupingPathLastComponent = uses.getGroupingPath().getLastComponent();
    assertEquals(groupingQName, usesGroupingPathLastComponent);
    assertEquals(0, getChildNodeSizeWithoutUses(schemaServiceContainer));

    final DataSchemaNode type = schemaServiceContainer.getDataChildByName(QName.create(module.getQNameModule(),
        "type"));
    final List<UnknownSchemaNode> typeUnknownSchemaNodes = type.getUnknownSchemaNodes();
    assertEquals(1, typeUnknownSchemaNodes.size());

    final UnknownSchemaNode typeUnknownSchemaNode = typeUnknownSchemaNodes.get(0);
    final QNameModule qNameModule = QNameModule.create(
        URI.create("urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom"), Revision.of("2013-10-28"));
    final QName qName = QName.create(qNameModule, "schema-service");

    assertEquals(qName, typeUnknownSchemaNode.getQName());
    assertEquals(typeUnknownSchemaNode.getQName(), typeUnknownSchemaNode
            .getPath().getLastComponent());
}