import org.eclipse.milo.opcua.stack.core.types.structured.ReadValueId; //导入依赖的package包/类
@Override
public void read(
        final ReadContext context,
        final Double maxAge,
        final TimestampsToReturn timestamps,
        final List<ReadValueId> readValueIds) {

    final List<DataValue> results = new ArrayList<>(readValueIds.size());

    for (final ReadValueId id : readValueIds) {
        final ServerNode node = this.nodeMap.get(id.getNodeId());

        final DataValue value = node != null
                ? node.readAttribute(new AttributeContext(context), id.getAttributeId())
                : new DataValue(StatusCodes.Bad_NodeIdUnknown);

        results.add(value);
    }

    // report back with result

    context.complete(results);
}
 

import org.eclipse.milo.opcua.stack.core.types.structured.ReadValueId; //导入依赖的package包/类
public CompletableFuture<ReadResponse> testStack(NodeId nodeId) {
    RequestHeader header = new RequestHeader(
        NodeId.NULL_VALUE,
        DateTime.now(),
        uint(requestHandle.getAndIncrement()),
        uint(0),
        null,
        uint(60000),
        null
    );

    ReadRequest request = new ReadRequest(
        header,
        0.0,
        TimestampsToReturn.Neither,
        new ReadValueId[]{
            new ReadValueId(
                nodeId,
                AttributeId.Value.uid(),
                null,
                null)
        }
    );

    return client.sendRequest(request);
}
 

import org.eclipse.milo.opcua.stack.core.types.structured.ReadValueId; //导入依赖的package包/类
private void setReadRequestHandler(Variant variant) {
    server.addRequestHandler(ReadRequest.class, service -> {
        ReadRequest request = service.getRequest();

        ResponseHeader header = new ResponseHeader(
            DateTime.now(),
            request.getRequestHeader().getRequestHandle(),
            StatusCode.GOOD,
            null,
            null,
            null
        );

        List<ReadValueId> nodesToRead = l(request.getNodesToRead());
        List<DataValue> results = Collections.nCopies(nodesToRead.size(), new DataValue(variant));

        ReadResponse response = new ReadResponse(header, a(results, DataValue.class), null);

        service.setResponse(response);
    });
}
 

import org.eclipse.milo.opcua.stack.core.types.structured.ReadValueId; //导入依赖的package包/类
/**
 * This service is used to read one or more attributes of one or more nodes.
 *
 * @param maxAge             the requested max age of the value, in milliseconds. If maxAge is set to 0, the Server
 *                           shall attempt to read a new value from the data source. If maxAge is set to the max
 *                           Int32 value or greater, the Server shall attempt to get a cached value. Negative values
 *                           are invalid for maxAge.
 * @param timestampsToReturn the requested {@link TimestampsToReturn}.
 * @param nodeIds            the {@link NodeId}s identifying the nodes to read.
 * @param attributeIds       the attribute ids to read, the size and order matching the provided {@link NodeId}s.
 * @return a {@link CompletableFuture} containing a list of {@link DataValue}s, the size and order matching the
 * provided {@link NodeId}s.
 */
default CompletableFuture<List<DataValue>> read(double maxAge,
                                                TimestampsToReturn timestampsToReturn,
                                                List<NodeId> nodeIds,
                                                List<UInteger> attributeIds) {

    if (nodeIds.size() != attributeIds.size()) {
        CompletableFuture<List<DataValue>> failed = new CompletableFuture<>();
        failed.completeExceptionally(new IllegalArgumentException("nodeIds.size() != attributeIds.size()"));
        return failed;
    } else {
        Stream<ReadValueId> stream = StreamUtils.zip(
            nodeIds.stream(), attributeIds.stream(),
            (nId, aId) -> new ReadValueId(nId, aId, null, QualifiedName.NULL_VALUE));

        return read(maxAge, timestampsToReturn, stream.collect(Collectors.toList()))
            .thenApply(r -> l(r.getResults()));
    }
}
 

import org.eclipse.milo.opcua.stack.core.types.structured.ReadValueId; //导入依赖的package包/类
public OpcUaMonitoredItem(
    OpcUaClient client,
    UInteger clientHandle,
    ReadValueId readValueId,
    UInteger monitoredItemId,
    StatusCode statusCode,
    double revisedSamplingInterval,
    UInteger revisedQueueSize,
    ExtensionObject filterResult,
    MonitoringMode monitoringMode,
    ExtensionObject monitoringFilter) {

    this.client = client;
    this.clientHandle = clientHandle;
    this.readValueId = readValueId;
    this.monitoredItemId = monitoredItemId;
    this.statusCode = statusCode;
    this.revisedSamplingInterval = revisedSamplingInterval;
    this.revisedQueueSize = revisedQueueSize;
    this.filterResult = filterResult;
    this.monitoringMode = monitoringMode;
    this.monitoringFilter = monitoringFilter;
}
 

import org.eclipse.milo.opcua.stack.core.types.structured.ReadValueId; //导入依赖的package包/类
protected CompletableFuture<DataValue> readAttribute(AttributeId attributeId) {
    Optional<DataValue> opt =
        AttributeId.BASE_NODE_ATTRIBUTES.contains(attributeId) ?
            nodeCache.getAttribute(nodeId, attributeId) : Optional.empty();

    return opt.map(CompletableFuture::completedFuture).orElseGet(() -> {
        ReadValueId readValueId = new ReadValueId(
            nodeId, attributeId.uid(), null, QualifiedName.NULL_VALUE);

        CompletableFuture<ReadResponse> future =
            client.read(0.0, TimestampsToReturn.Both, newArrayList(readValueId));

        return future.thenApply(response -> {
            DataValue value = l(response.getResults()).get(0);

            if (attributeId != AttributeId.Value) {
                nodeCache.putAttribute(nodeId, attributeId, value);
            }

            return value;
        });
    });
}
 

import org.eclipse.milo.opcua.stack.core.types.structured.ReadValueId; //导入依赖的package包/类
@Override
public CompletableFuture<UaNode> createNode(NodeId nodeId) {
    ReadValueId readValueId = new ReadValueId(
        nodeId, AttributeId.NodeClass.uid(), null, QualifiedName.NULL_VALUE);

    CompletableFuture<ReadResponse> future =
        client.read(0.0, TimestampsToReturn.Neither, newArrayList(readValueId));

    return future.thenCompose(response -> {
        DataValue value = l(response.getResults()).get(0);
        NodeClass nodeClass = NodeClass.from((Integer) value.getValue().getValue());

        if (nodeClass != null) {
            client.getNodeCache().putAttribute(nodeId, AttributeId.NodeClass, value);

            return completedFuture(createNode(nodeId, nodeClass));
        } else {
            return failedFuture(new UaException(value.getStatusCode(), "NodeClass was null"));
        }
    });
}
 

import org.eclipse.milo.opcua.stack.core.types.structured.ReadValueId; //导入依赖的package包/类
private CompletableFuture<List<DataValue>> readDataAttributes(Session session, Namespace namespace, NodeId itemId) {
    Function<AttributeId, ReadValueId> f = id ->
        new ReadValueId(itemId, id.uid(), null, QualifiedName.NULL_VALUE);

    CompletableFuture<List<DataValue>> future = new CompletableFuture<>();

    ReadContext readContext = new ReadContext(
        server, session, future, new DiagnosticsContext<>());

    List<ReadValueId> attributes = newArrayList(
        f.apply(AttributeId.AccessLevel),
        f.apply(AttributeId.UserAccessLevel),
        f.apply(AttributeId.MinimumSamplingInterval));

    namespace.read(readContext, 0.0, TimestampsToReturn.Neither, attributes);

    return future;
}
 

import org.eclipse.milo.opcua.stack.core.types.structured.ReadValueId; //导入依赖的package包/类
@Override
public void read(
    ReadContext context,
    Double maxAge,
    TimestampsToReturn timestamps,
    List<ReadValueId> readValueIds) {

    List<DataValue> results = Lists.newArrayListWithCapacity(readValueIds.size());

    for (ReadValueId id : readValueIds) {
        ServerNode node = nodeMap.get(id.getNodeId());

        DataValue value = (node != null) ?
            node.readAttribute(new AttributeContext(context), id.getAttributeId()) :
            new DataValue(StatusCodes.Bad_NodeIdUnknown);

        results.add(value);
    }

    context.complete(results);
}
 

import org.eclipse.milo.opcua.stack.core.types.structured.ReadValueId; //导入依赖的package包/类
public MonitoredDataItem(
    UInteger id,
    UInteger subscriptionId,
    ReadValueId readValueId,
    MonitoringMode monitoringMode,
    TimestampsToReturn timestamps,
    UInteger clientHandle,
    double samplingInterval,
    ExtensionObject filter,
    UInteger queueSize,
    boolean discardOldest) throws UaException {

    super(id, subscriptionId, readValueId, monitoringMode,
        timestamps, clientHandle, samplingInterval, queueSize, discardOldest);

    installFilter(filter);
}
 

import org.eclipse.milo.opcua.stack.core.types.structured.ReadValueId; //导入依赖的package包/类
public MonitoredEventItem(
    UInteger id,
    UInteger subscriptionId,
    ReadValueId readValueId,
    MonitoringMode monitoringMode,
    TimestampsToReturn timestamps,
    UInteger clientHandle,
    double samplingInterval,
    UInteger queueSize,
    boolean discardOldest,
    ExtensionObject filter) throws UaException {

    super(id, subscriptionId, readValueId, monitoringMode,
        timestamps, clientHandle, samplingInterval, queueSize, discardOldest);

    installFilter(filter);
}
 

import org.eclipse.milo.opcua.stack.core.types.structured.ReadValueId; //导入依赖的package包/类
protected BaseMonitoredItem(
    UInteger id,
    UInteger subscriptionId,
    ReadValueId readValueId,
    MonitoringMode monitoringMode,
    TimestampsToReturn timestamps,
    UInteger clientHandle,
    double samplingInterval,
    UInteger queueSize,
    boolean discardOldest) {

    this.id = id;
    this.subscriptionId = subscriptionId;
    this.readValueId = readValueId;
    this.monitoringMode = monitoringMode;
    this.timestamps = timestamps;
    this.clientHandle = clientHandle.longValue();
    this.samplingInterval = samplingInterval;
    this.discardOldest = discardOldest;

    setQueueSize(queueSize);

    queue = new RingBuffer<>(this.queueSize);
}
 

import org.eclipse.milo.opcua.stack.core.types.structured.ReadValueId; //导入依赖的package包/类
@DataProvider
public Object[][] getVariants() {
    return new Object[][]{
        {new Variant(true)},
        {new Variant((byte) 1)},
        {new Variant(ubyte(1))},
        {new Variant((short) 1)},
        {new Variant(ushort(1))},
        {new Variant(1)},
        {new Variant(uint(1))},
        {new Variant(1L)},
        {new Variant(ulong(1L))},
        {new Variant(3.14f)},
        {new Variant(6.12d)},
        {new Variant("hello, world")},
        {new Variant(DateTime.now())},
        {new Variant(UUID.randomUUID())},
        {new Variant(ByteString.of(new byte[]{1, 2, 3, 4}))},
        {new Variant(new XmlElement("<tag>hello</tag>"))},
        {new Variant(new NodeId(0, 42))},
        {new Variant(new ExpandedNodeId(1, 42, "uri", 1))},
        {new Variant(StatusCode.GOOD)},
        {new Variant(new QualifiedName(0, "QualifiedName"))},
        {new Variant(LocalizedText.english("LocalizedText"))},
        {new Variant(ExtensionObject.encode(new ReadValueId(NodeId.NULL_VALUE, uint(1), null, new QualifiedName(0, "DataEncoding"))))},
    };
}
 

import org.eclipse.milo.opcua.stack.core.types.structured.ReadValueId; //导入依赖的package包/类
@Override
public void read(ReadContext context, Double maxAge, TimestampsToReturn timestamps, List<ReadValueId> readValueIds) {
    List<DataValue> results = Lists.newArrayListWithCapacity(readValueIds.size());

    for (ReadValueId id : readValueIds) {
        ServerNode node = nodeManager.get(id.getNodeId());

        if (node != null) {
            DataValue value = node.readAttribute(
                new AttributeContext(context),
                id.getAttributeId(),
                timestamps,
                id.getIndexRange()
            );

            if (logger.isTraceEnabled()) {
                Variant variant = value.getValue();
                Object o = variant != null ? variant.getValue() : null;
                logger.trace("Read value={} from attributeId={} of {}",
                    o, id.getAttributeId(), id.getNodeId());
            }

            results.add(value);
        } else {
            results.add(new DataValue(new StatusCode(StatusCodes.Bad_NodeIdUnknown)));
        }
    }

    context.complete(results);
}
 

import org.eclipse.milo.opcua.stack.core.types.structured.ReadValueId; //导入依赖的package包/类
private void createItemAndWait(
    UaSubscription.NotificationListener notificationListener,
    Object notificationLock) throws InterruptedException, ExecutionException {

    // create a subscription and a monitored item
    UaSubscription subscription = client.getSubscriptionManager().createSubscription(1000.0).get();
    subscription.addNotificationListener(notificationListener);

    ReadValueId readValueId = new ReadValueId(
        Identifiers.Server_ServerStatus_State,
        AttributeId.Value.uid(), null, QualifiedName.NULL_VALUE);

    MonitoringParameters parameters = new MonitoringParameters(
        uint(1),    // client handle
        1000.0,     // sampling interval
        null,       // no (default) filter
        uint(10),   // queue size
        true);      // discard oldest

    MonitoredItemCreateRequest request = new MonitoredItemCreateRequest(
        readValueId, MonitoringMode.Reporting, parameters);

    synchronized (notificationLock) {
        subscription.createMonitoredItems(TimestampsToReturn.Both, newArrayList(request)).get();
        notificationLock.wait(5000);
    }
}
 

import org.eclipse.milo.opcua.stack.core.types.structured.ReadValueId; //导入依赖的package包/类
private void testReadDataTypeDictionaryBytes(ByteString dictionary, int fragmentSize) throws Exception {
    Mockito
        .when(stackClient.<ReadResponse>sendRequest(any(ReadRequest.class)))
        .then(invocationOnMock -> {
            ReadRequest readRequest = invocationOnMock.getArgument(0);

            List<ReadValueId> readValueIds =
                Arrays.stream(Objects.requireNonNull(readRequest.getNodesToRead()))
                    .collect(Collectors.toList());

            ReadValueId readValueId = readValueIds.get(0);

            NumericRange numericRange = NumericRange.parse(readValueId.getIndexRange());

            try {
                Object fragment = NumericRange.readFromValueAtRange(new Variant(dictionary), numericRange);

                return completedFuture(new ReadResponse(
                    null,
                    new DataValue[]{new DataValue(new Variant(fragment))},
                    null
                ));
            } catch (UaException e) {
                return completedFuture(new ReadResponse(
                    null,
                    new DataValue[]{new DataValue(e.getStatusCode())},
                    null
                ));
            }
        });

    ByteString typeDictionaryBs = dictionaryReader.readDataTypeDictionaryBytes(
        NodeId.NULL_VALUE,
        fragmentSize
    ).get();

    assertEquals(typeDictionaryBs, dictionary);
}
 

import org.eclipse.milo.opcua.stack.core.types.structured.ReadValueId; //导入依赖的package包/类
@Override
public CompletableFuture<ReadResponse> read(double maxAge,
                                            TimestampsToReturn timestampsToReturn,
                                            List<ReadValueId> readValueIds) {

    return getSession().thenCompose(session -> {
        ReadRequest request = new ReadRequest(
            newRequestHeader(session.getAuthenticationToken()),
            maxAge,
            timestampsToReturn,
            a(readValueIds, ReadValueId.class));

        return sendRequest(request);
    });
}
 

import org.eclipse.milo.opcua.stack.core.types.structured.ReadValueId; //导入依赖的package包/类
private CompletableFuture<List<String>> readDataTypeDescriptionValues(List<NodeId> nodeIds) {
    CompletableFuture<UInteger> maxNodesPerRead = readNode(
        new ReadValueId(
            Identifiers.Server_ServerCapabilities_OperationLimits_MaxNodesPerRead,
            AttributeId.Value.uid(),
            null,
            QualifiedName.NULL_VALUE
        )
    ).thenApply(dv -> (UInteger) dv.getValue().getValue());

    CompletableFuture<Integer> getPartitionSize = maxNodesPerRead
        .thenApply(m -> Math.max(1, Ints.saturatedCast(m.longValue())))
        .exceptionally(ex -> PARTITION_SIZE);

    return getPartitionSize.thenCompose(partitionSize -> {
        List<List<NodeId>> partitions = Lists.partition(nodeIds, partitionSize);

        CompletableFuture<List<List<DataValue>>> sequence = FutureUtils.sequence(
            partitions.stream().map(list -> {
                List<ReadValueId> readValueIds = list.stream()
                    .map(nodeId ->
                        new ReadValueId(
                            nodeId,
                            AttributeId.Value.uid(),
                            null,
                            QualifiedName.NULL_VALUE))
                    .collect(Collectors.toList());

                return readNodes(readValueIds);
            })
        );

        return sequence.thenApply(values ->
            values.stream()
                .flatMap(List::stream)
                .map(v -> (String) v.getValue().getValue())
                .collect(Collectors.toList())
        );
    });
}
 

import org.eclipse.milo.opcua.stack.core.types.structured.ReadValueId; //导入依赖的package包/类
private CompletableFuture<List<DataValue>> readNodes(List<ReadValueId> readValueIds) {
    RequestHeader requestHeader = stackClient.newRequestHeader(
        session.getAuthenticationToken(),
        uint(60000)
    );

    ReadRequest readRequest = new ReadRequest(
        requestHeader,
        0.0,
        TimestampsToReturn.Neither,
        readValueIds.toArray(new ReadValueId[0])
    );

    return stackClient.<ReadResponse>sendRequest(readRequest).thenApply(r -> l(r.getResults()));
}
 

import org.eclipse.milo.opcua.stack.core.types.structured.ReadValueId; //导入依赖的package包/类
public ReadContext(OpcUaServer server,
                   @Nullable Session session,
                   CompletableFuture<List<DataValue>> future,
                   DiagnosticsContext<ReadValueId> diagnosticsContext) {

    super(server, session, future, diagnosticsContext);
}