Java NormalizedNode.getValue方法代码示例

import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; //导入方法依赖的package包/类
@Test
public void testSerializeDeserializeAnyXmlNode() throws Exception {
    final ByteArrayInputStream is =
            new ByteArrayInputStream("<xml><data/></xml>".getBytes(Charset.defaultCharset()));
    final Document parse = UntrustedXML.newDocumentBuilder().parse(is);
    final AnyXmlNode anyXmlNode = Builders.anyXmlBuilder()
            .withNodeIdentifier(id("anyXmlNode"))
            .withValue(new DOMSource(parse))
            .build();
    final byte[] bytes = SerializationUtils.serializeNormalizedNode(anyXmlNode);
    final NormalizedNode<?, ?> deserialized = SerializationUtils.deserializeNormalizedNode(bytes);
    final DOMSource value = (DOMSource) deserialized.getValue();
    final Diff diff = XMLUnit.compareXML((Document) anyXmlNode.getValue().getNode(),
            value.getNode().getOwnerDocument());
    Assert.assertTrue(diff.toString(), diff.similar());
}
 

import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; //导入方法依赖的package包/类
@Override
protected CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(final NormalizedNode<?, ?> input) {
    final Optional<NormalizedNode<?, ?>> maybeKey = NormalizedNodes.findNode(input, keyId);

    // Routing key is present, attempt to deliver as a routed RPC
    if (maybeKey.isPresent()) {
        final NormalizedNode<?, ?> key = maybeKey.get();
        final Object value = key.getValue();
        if (value instanceof YangInstanceIdentifier) {
            final YangInstanceIdentifier iid = (YangInstanceIdentifier) value;

            // Find a DOMRpcImplementation for a specific iid
            final List<DOMRpcImplementation> specificImpls = getImplementations(iid);
            if (specificImpls != null) {
                return specificImpls.get(0).invokeRpc(DOMRpcIdentifier.create(getSchemaPath(), iid), input);
            }

            LOG.debug("No implementation for context {} found will now look for wildcard id", iid);

            // Find a DOMRpcImplementation for a wild card. Usually remote-rpc-connector would register an
            // implementation this way
            final List<DOMRpcImplementation> mayBeRemoteImpls = getImplementations(YangInstanceIdentifier.EMPTY);

            if(mayBeRemoteImpls != null){
                return mayBeRemoteImpls.get(0).invokeRpc(DOMRpcIdentifier.create(getSchemaPath(), iid), input);
            }

        } else {
            LOG.warn("Ignoring wrong context value {}", value);
        }
    }

    final List<DOMRpcImplementation> impls = getImplementations(null);
    if (impls != null) {
        return impls.get(0).invokeRpc(globalRpcId, input);
    } else {
        return Futures.<DOMRpcResult, DOMRpcException>immediateFailedCheckedFuture(new DOMRpcImplementationNotAvailableException("No implementation of RPC %s available", getSchemaPath()));
    }
}
 

import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; //导入方法依赖的package包/类
private void recordOp(LogicalDatastoreType store, YangInstanceIdentifier yiid, String method,
        NormalizedNode<?, ?> node) {
    if (!tracingBroker.isWriteWatched(yiid, store)) {
        return;
    }

    final Object value = node != null ? node.getValue() : null;

    if (value != null && value instanceof ImmutableSet && ((Set<?>)value).isEmpty()) {
        if (TracingBroker.LOG.isDebugEnabled()) {
            TracingBroker.LOG.debug("Empty data set write to {}", tracingBroker.toPathString(yiid));
        }
    } else {
        StringBuilder sb = new StringBuilder();
        sb.append("Method \"").append(method);
        sb.append("\" to ").append(store);
        sb.append(" at ").append(tracingBroker.toPathString(yiid)).append('.');
        sb.append(" Data: ");
        if (node != null) {
            sb.append(node.getValue());
        } else {
            sb.append("null");
        }
        sb.append(" Stack:").append(tracingBroker.getStackSummary());
        synchronized (this) {
            logs.add(sb.toString());
        }
    }
}
 

import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; //导入方法依赖的package包/类
@Test
public void testAggregate() throws InterruptedException, ExecutionException, ReadFailedException,
        DataValidationFailedException {
    SchemaContext schemaContext = SchemaContextHelper.full();
    NormalizedNode<?, ?> expectedNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
    NormalizedNode<?, ?> expectedNode2 = ImmutableNodes.containerNode(CarsModel.CARS_QNAME);

    Optional<NormalizedNode<?, ?>> optional = NormalizedNodeAggregator.aggregate(YangInstanceIdentifier.EMPTY,
            ImmutableList.of(
                    Optional.<NormalizedNode<?, ?>>of(getRootNode(expectedNode1, schemaContext)),
                    Optional.<NormalizedNode<?, ?>>of(getRootNode(expectedNode2, schemaContext))),
            schemaContext, LogicalDatastoreType.CONFIGURATION);


    NormalizedNode<?,?> normalizedNode = optional.get();

    assertTrue("Expect value to be a Collection", normalizedNode.getValue() instanceof Collection);

    @SuppressWarnings("unchecked")
    Collection<NormalizedNode<?,?>> collection = (Collection<NormalizedNode<?,?>>) normalizedNode.getValue();

    for (NormalizedNode<?,?> node : collection) {
        assertTrue("Expected " + node + " to be a ContainerNode", node instanceof ContainerNode);
    }

    assertTrue("Child with QName = " + TestModel.TEST_QNAME + " not found",
            findChildWithQName(collection, TestModel.TEST_QNAME) != null);

    assertEquals(expectedNode1, findChildWithQName(collection, TestModel.TEST_QNAME));

    assertTrue("Child with QName = " + CarsModel.BASE_QNAME + " not found",
            findChildWithQName(collection, CarsModel.BASE_QNAME) != null);

    assertEquals(expectedNode2, findChildWithQName(collection, CarsModel.BASE_QNAME));

}
 

import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; //导入方法依赖的package包/类
@Test
public void testReadRoot() throws ReadFailedException, InterruptedException, ExecutionException,
        java.util.concurrent.TimeoutException {
    SchemaContext schemaContext = SchemaContextHelper.full();
    Configuration configuration = mock(Configuration.class);
    doReturn(configuration).when(mockActorContext).getConfiguration();
    doReturn(schemaContext).when(mockActorContext).getSchemaContext();
    doReturn(Sets.newHashSet("test", "cars")).when(configuration).getAllShardNames();

    NormalizedNode<?, ?> expectedNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
    NormalizedNode<?, ?> expectedNode2 = ImmutableNodes.containerNode(CarsModel.CARS_QNAME);

    setUpReadData("test", NormalizedNodeAggregatorTest.getRootNode(expectedNode1, schemaContext));
    setUpReadData("cars", NormalizedNodeAggregatorTest.getRootNode(expectedNode2, schemaContext));

    doReturn(MemberName.forName(memberName)).when(mockActorContext).getCurrentMemberName();

    doReturn(getSystem().dispatchers().defaultGlobalDispatcher()).when(mockActorContext).getClientDispatcher();

    TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);

    Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
            YangInstanceIdentifier.EMPTY).get(5, TimeUnit.SECONDS);

    assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());

    NormalizedNode<?, ?> normalizedNode = readOptional.get();

    assertTrue("Expect value to be a Collection", normalizedNode.getValue() instanceof Collection);

    @SuppressWarnings("unchecked")
    Collection<NormalizedNode<?,?>> collection = (Collection<NormalizedNode<?,?>>) normalizedNode.getValue();

    for (NormalizedNode<?,?> node : collection) {
        assertTrue("Expected " + node + " to be a ContainerNode", node instanceof ContainerNode);
    }

    assertTrue("Child with QName = " + TestModel.TEST_QNAME + " not found",
            NormalizedNodeAggregatorTest.findChildWithQName(collection, TestModel.TEST_QNAME) != null);

    assertEquals(expectedNode1, NormalizedNodeAggregatorTest.findChildWithQName(collection, TestModel.TEST_QNAME));

    assertTrue("Child with QName = " + CarsModel.BASE_QNAME + " not found",
            NormalizedNodeAggregatorTest.findChildWithQName(collection, CarsModel.BASE_QNAME) != null);

    assertEquals(expectedNode2, NormalizedNodeAggregatorTest.findChildWithQName(collection, CarsModel.BASE_QNAME));
}
 

import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; //导入方法依赖的package包/类
protected void testRecovery(final Set<Integer> listEntryKeys) throws Exception {
    // Create the actor and wait for recovery complete.

    final int nListEntries = listEntryKeys.size();

    final CountDownLatch recoveryComplete = new CountDownLatch(1);

    final Creator<Shard> creator = () -> new Shard(newShardBuilder()) {
        @Override
        protected void onRecoveryComplete() {
            try {
                super.onRecoveryComplete();
            } finally {
                recoveryComplete.countDown();
            }
        }
    };

    final TestActorRef<Shard> shard = TestActorRef.create(getSystem(),
            Props.create(new DelegatingShardCreator(creator)).withDispatcher(Dispatchers.DefaultDispatcherId()),
            "testRecovery");

    assertEquals("Recovery complete", true, recoveryComplete.await(5, TimeUnit.SECONDS));

    // Verify data in the data store.

    final NormalizedNode<?, ?> outerList = readStore(shard, TestModel.OUTER_LIST_PATH);
    assertNotNull(TestModel.OUTER_LIST_QNAME.getLocalName() + " not found", outerList);
    assertTrue(TestModel.OUTER_LIST_QNAME.getLocalName() + " value is not Iterable",
            outerList.getValue() instanceof Iterable);
    for (final Object entry: (Iterable<?>) outerList.getValue()) {
        assertTrue(TestModel.OUTER_LIST_QNAME.getLocalName() + " entry is not MapEntryNode",
                entry instanceof MapEntryNode);
        final MapEntryNode mapEntry = (MapEntryNode)entry;
        final Optional<DataContainerChild<? extends PathArgument, ?>> idLeaf =
                mapEntry.getChild(new YangInstanceIdentifier.NodeIdentifier(TestModel.ID_QNAME));
        assertTrue("Missing leaf " + TestModel.ID_QNAME.getLocalName(), idLeaf.isPresent());
        final Object value = idLeaf.get().getValue();
        assertTrue("Unexpected value for leaf " + TestModel.ID_QNAME.getLocalName() + ": " + value,
                listEntryKeys.remove(value));
    }

    if (!listEntryKeys.isEmpty()) {
        fail("Missing " + TestModel.OUTER_LIST_QNAME.getLocalName() + " entries with keys: " + listEntryKeys);
    }

    assertEquals("Last log index", nListEntries,
            shard.underlyingActor().getShardMBean().getLastLogIndex());
    assertEquals("Commit index", nListEntries,
            shard.underlyingActor().getShardMBean().getCommitIndex());
    assertEquals("Last applied", nListEntries,
            shard.underlyingActor().getShardMBean().getLastApplied());

    shard.tell(PoisonPill.getInstance(), ActorRef.noSender());
}