Java AccessLevel类代码示例

import org.eclipse.milo.opcua.sdk.core.AccessLevel; //导入依赖的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.sdk.core.AccessLevel; //导入依赖的package包/类
private void testWriteConversion(
    DataValue value,
    NodeId dataType,
    Consumer<UaVariableNode> nodeCustomizer) throws UaException {

    final UaVariableNode varNode = createMockNode("test", node -> {
        UByte accessLevel = ubyte(AccessLevel.getMask(AccessLevel.READ_WRITE));
        node.setAccessLevel(accessLevel);
        node.setUserAccessLevel(accessLevel);
        if (nodeCustomizer != null) {
            nodeCustomizer.accept(node);
        }
    });

    if (dataType != null) {
        varNode.setDataType(dataType);
    }

    AttributeWriter.writeAttribute(new AttributeContext(null, null), varNode, AttributeId.Value, value, null);
}
 

import org.eclipse.milo.opcua.sdk.core.AccessLevel; //导入依赖的package包/类
public CamelServerItem(final String itemId, final ServerNodeMap nodeManager, final UShort namespaceIndex,
		final UaObjectNode baseNode) {

	this.baseNode = baseNode;

	final NodeId nodeId = new NodeId(namespaceIndex, "items-" + itemId);
	final QualifiedName qname = new QualifiedName(namespaceIndex, itemId);
	final LocalizedText displayName = LocalizedText.english(itemId);

	// create variable node

	this.item = new UaVariableNode(nodeManager, nodeId, qname, displayName) {

		@Override
		public DataValue getValue() {
			return getDataValue();
		}

		@Override
		public synchronized void setValue(final DataValue value) {
			setDataValue(value);
		}

	};

	// item.setDataType();
	this.item.setAccessLevel(ubyte(AccessLevel.getMask(AccessLevel.READ_WRITE)));
	this.item.setUserAccessLevel(ubyte(AccessLevel.getMask(AccessLevel.READ_WRITE)));

	baseNode.addComponent(this.item);
}
 

import org.eclipse.milo.opcua.sdk.core.AccessLevel; //导入依赖的package包/类
private void addStaticScalarNodes() {
    UaObjectNode folder = addFoldersToRoot(testFolder, "/Static/AllProfiles/Scalar");

    for (Object[] os : STATIC_SCALAR_NODES) {
        String name = (String) os[0];
        NodeId typeId = (NodeId) os[1];
        Variant variant = (Variant) os[2];

        UaVariableNode node = new UaVariableNode.UaVariableNodeBuilder(nodeManager)
            .setNodeId(new NodeId(namespaceIndex, "/Static/AllProfiles/Scalar/" + name))
            .setAccessLevel(ubyte(AccessLevel.getMask(AccessLevel.READ_WRITE)))
            .setUserAccessLevel(ubyte(AccessLevel.getMask(AccessLevel.READ_WRITE)))
            .setBrowseName(new QualifiedName(namespaceIndex, name))
            .setDisplayName(LocalizedText.english(name))
            .setDataType(typeId)
            .setTypeDefinition(Identifiers.BaseDataVariableType)
            .build();

        node.setValue(new DataValue(variant));

        folder.addReference(new Reference(
            folder.getNodeId(),
            Identifiers.Organizes,
            node.getNodeId().expanded(),
            node.getNodeClass(),
            true
        ));

        logger.debug("Added reference: {} -> {}", folder.getNodeId(), node.getNodeId());

        nodeManager.put(node.getNodeId(), node);
    }
}
 

import org.eclipse.milo.opcua.sdk.core.AccessLevel; //导入依赖的package包/类
private CompletableFuture<EventAttributes> readEventAttributes(Namespace namespace, NodeId nodeId) {
    Function<AttributeId, ReadValueId> f = id ->
        new ReadValueId(nodeId, id.uid(), null, QualifiedName.NULL_VALUE);

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

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

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

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

    return future.thenApply(values -> {
        UByte accessLevel = Optional.ofNullable((UByte) values.get(0).getValue().getValue()).orElse(ubyte(1));
        UByte userAccessLevel = Optional.ofNullable((UByte) values.get(1).getValue().getValue()).orElse(ubyte(1));
        Optional<UByte> eventNotifier = Optional.ofNullable((UByte) values.get(2).getValue().getValue());

        return new EventAttributes(
            AccessLevel.fromMask(accessLevel),
            AccessLevel.fromMask(userAccessLevel),
            eventNotifier);
    });
}
 

import org.eclipse.milo.opcua.sdk.core.AccessLevel; //导入依赖的package包/类
public static Set<AccessLevel> getAccessLevels(
    ServerNode node,
    AttributeContext context) throws UaException {

    UByte accessLevel = extract(
        node.getAttribute(
            context,
            AttributeId.AccessLevel)
    );

    return AccessLevel.fromMask(accessLevel);
}
 

import org.eclipse.milo.opcua.sdk.core.AccessLevel; //导入依赖的package包/类
public static Set<AccessLevel> getUserAccessLevels(
    ServerNode node,
    AttributeContext context) throws UaException {

    UByte userAccessLevel = extract(
        node.getAttribute(
            context,
            AttributeId.UserAccessLevel)
    );

    return AccessLevel.fromMask(userAccessLevel);
}
 

import org.eclipse.milo.opcua.sdk.core.AccessLevel; //导入依赖的package包/类
@Override
public UByte getUserAccessLevel(AttributeContext context, VariableNode node) throws UaException {
    Optional<Object> identity = context.getSession().map(Session::getIdentityObject);

    Set<AccessLevel> accessLevels = identity.map(accessLevelsFn).orElse(INTERNAL_ACCESS);

    return ubyte(AccessLevel.getMask(accessLevels));
}
 

import org.eclipse.milo.opcua.sdk.core.AccessLevel; //导入依赖的package包/类
private void addScalarNodes(UaFolderNode rootNode) {
    UaFolderNode scalarTypesFolder = new UaFolderNode(
        server.getNodeMap(),
        new NodeId(namespaceIndex, "HelloWorld/ScalarTypes"),
        new QualifiedName(namespaceIndex, "ScalarTypes"),
        LocalizedText.english("ScalarTypes")
    );

    server.getNodeMap().addNode(scalarTypesFolder);
    rootNode.addOrganizes(scalarTypesFolder);

    for (Object[] os : STATIC_SCALAR_NODES) {
        String name = (String) os[0];
        NodeId typeId = (NodeId) os[1];
        Variant variant = (Variant) os[2];

        UaVariableNode node = new UaVariableNode.UaVariableNodeBuilder(server.getNodeMap())
            .setNodeId(new NodeId(namespaceIndex, "HelloWorld/ScalarTypes/" + name))
            .setAccessLevel(ubyte(AccessLevel.getMask(AccessLevel.READ_WRITE)))
            .setUserAccessLevel(ubyte(AccessLevel.getMask(AccessLevel.READ_WRITE)))
            .setBrowseName(new QualifiedName(namespaceIndex, name))
            .setDisplayName(LocalizedText.english(name))
            .setDataType(typeId)
            .setTypeDefinition(Identifiers.BaseDataVariableType)
            .build();

        node.setValue(new DataValue(variant));

        node.setAttributeDelegate(new ValueLoggingDelegate());

        server.getNodeMap().addNode(node);
        scalarTypesFolder.addOrganizes(node);
    }
}
 

import org.eclipse.milo.opcua.sdk.core.AccessLevel; //导入依赖的package包/类
private void addAdminReadableNodes(UaFolderNode rootNode) {
    UaFolderNode adminFolder = new UaFolderNode(
        server.getNodeMap(),
        new NodeId(namespaceIndex, "HelloWorld/OnlyAdminCanRead"),
        new QualifiedName(namespaceIndex, "OnlyAdminCanRead"),
        LocalizedText.english("OnlyAdminCanRead")
    );

    server.getNodeMap().addNode(adminFolder);
    rootNode.addOrganizes(adminFolder);

    String name = "String";
    UaVariableNode node = new UaVariableNode.UaVariableNodeBuilder(server.getNodeMap())
        .setNodeId(new NodeId(namespaceIndex, "HelloWorld/OnlyAdminCanRead/" + name))
        .setAccessLevel(ubyte(AccessLevel.getMask(AccessLevel.READ_WRITE)))
        .setBrowseName(new QualifiedName(namespaceIndex, name))
        .setDisplayName(LocalizedText.english(name))
        .setDataType(Identifiers.String)
        .setTypeDefinition(Identifiers.BaseDataVariableType)
        .build();

    node.setValue(new DataValue(new Variant("shh... don't tell the lusers")));

    node.setAttributeDelegate(new RestrictedAccessDelegate(identity -> {
        if ("admin".equals(identity)) {
            return AccessLevel.READ_WRITE;
        } else {
            return AccessLevel.NONE;
        }
    }));

    server.getNodeMap().addNode(node);
    adminFolder.addOrganizes(node);
}
 

import org.eclipse.milo.opcua.sdk.core.AccessLevel; //导入依赖的package包/类
private void addAdminWritableNodes(UaFolderNode rootNode) {
    UaFolderNode adminFolder = new UaFolderNode(
        server.getNodeMap(),
        new NodeId(namespaceIndex, "HelloWorld/OnlyAdminCanWrite"),
        new QualifiedName(namespaceIndex, "OnlyAdminCanWrite"),
        LocalizedText.english("OnlyAdminCanWrite")
    );

    server.getNodeMap().addNode(adminFolder);
    rootNode.addOrganizes(adminFolder);

    String name = "String";
    UaVariableNode node = new UaVariableNode.UaVariableNodeBuilder(server.getNodeMap())
        .setNodeId(new NodeId(namespaceIndex, "HelloWorld/OnlyAdminCanWrite/" + name))
        .setAccessLevel(ubyte(AccessLevel.getMask(AccessLevel.READ_WRITE)))
        .setBrowseName(new QualifiedName(namespaceIndex, name))
        .setDisplayName(LocalizedText.english(name))
        .setDataType(Identifiers.String)
        .setTypeDefinition(Identifiers.BaseDataVariableType)
        .build();

    node.setValue(new DataValue(new Variant("admin was here")));

    node.setAttributeDelegate(new RestrictedAccessDelegate(identity -> {
        if ("admin".equals(identity)) {
            return AccessLevel.READ_WRITE;
        } else {
            return AccessLevel.READ_ONLY;
        }
    }));

    server.getNodeMap().addNode(node);
    adminFolder.addOrganizes(node);
}
 

import org.eclipse.milo.opcua.sdk.core.AccessLevel; //导入依赖的package包/类
public EventAttributes(EnumSet<AccessLevel> v1, EnumSet<AccessLevel> v2, Optional<UByte> v3) {
    super(v1, v2, v3);
}
 

import org.eclipse.milo.opcua.sdk.core.AccessLevel; //导入依赖的package包/类
@Override
public synchronized void setAccessLevel(UByte accessLevel) {
    this.accessLevel = accessLevel;

    fireAttributeChanged(AttributeId.AccessLevel, accessLevel);
}
 

import org.eclipse.milo.opcua.sdk.core.AccessLevel; //导入依赖的package包/类
private static WriteMask writeMaskForAttribute(AttributeId attributeId) {
    switch (attributeId) {
        case AccessLevel:
            return WriteMask.AccessLevel;
        case ArrayDimensions:
            return WriteMask.ArrayDimensions;
        case BrowseName:
            return WriteMask.BrowseName;
        case ContainsNoLoops:
            return WriteMask.ContainsNoLoops;
        case DataType:
            return WriteMask.DataType;
        case Description:
            return WriteMask.Description;
        case DisplayName:
            return WriteMask.DisplayName;
        case EventNotifier:
            return WriteMask.EventNotifier;
        case Executable:
            return WriteMask.Executable;
        case Historizing:
            return WriteMask.Historizing;
        case InverseName:
            return WriteMask.InverseName;
        case IsAbstract:
            return WriteMask.IsAbstract;
        case MinimumSamplingInterval:
            return WriteMask.MinimumSamplingInterval;
        case NodeClass:
            return WriteMask.NodeClass;
        case NodeId:
            return WriteMask.NodeId;
        case Symmetric:
            return WriteMask.Symmetric;
        case UserAccessLevel:
            return WriteMask.UserAccessLevel;
        case UserExecutable:
            return WriteMask.UserExecutable;
        case UserWriteMask:
            return WriteMask.UserWriteMask;
        case Value:
            return WriteMask.ValueForVariableType;
        case ValueRank:
            return WriteMask.ValueRank;
        case WriteMask:
            return WriteMask.WriteMask;

        default:
            throw new IllegalArgumentException("unknown AttributeId: " + attributeId);
    }
}
 

import org.eclipse.milo.opcua.sdk.core.AccessLevel; //导入依赖的package包/类
public RestrictedAccessDelegate(Function<Object, Set<AccessLevel>> accessLevelsFn) {
    this(null, accessLevelsFn);
}