private void showRootNodes() throws Exception {
	TreeItem<OpcUaTreeNode> rootItem = new TreeItem<>();
	tvBrowser.setRoot(rootItem);
	rootItem.setExpanded(true);

	// browse root folder
	List<ReferenceDescription> refs = getApp().getOpcUaClient().browseSynch(Identifiers.RootFolder);

	for (ReferenceDescription ref : refs) {
		// child nodes
		TreeItem<OpcUaTreeNode> childItem = new TreeItem<>(new OpcUaTreeNode(ref));
		ImageView imageView = new ImageView(getNodeImage(ref));
		childItem.setGraphic(imageView);

		rootItem.getChildren().add(childItem);
	}
}
 

public static CompletableFuture<BrowsePathResult> translate(
        final OpcUaClient client,
        final NodeId startingNode,
        final String... path) {

    Objects.requireNonNull(startingNode);
    Objects.requireNonNull(path);

    // convert to elements

    final RelativePathElement[] elements = new RelativePathElement[path.length];
    for (int i = 0; i < path.length; i++) {
        elements[i] = new RelativePathElement(
                Identifiers.HierarchicalReferences,
                false, true,
                QualifiedName.parse(path[i]));
    }

    // translate

    final BrowsePath request = new BrowsePath(startingNode, new RelativePath(elements));
    return client.translateBrowsePaths(singletonList(request)).thenApply(response -> response.getResults()[0]);
}
 

private NodeId translateBrowsePath ( final String itemName )
{
    try
    {
        final RelativePathElement[] relativePaths = Arrays.asList ( itemName.split ( "\\." ) ).stream ().map ( //
                element -> new RelativePathElement ( Identifiers.HierarchicalReferences, false, true, new QualifiedName ( itemName.startsWith ( "Server." ) ? 0 : 2, element ) ) ).toArray ( RelativePathElement[]::new );
        final TranslateBrowsePathsToNodeIdsResponse response = this.client.translateBrowsePaths ( Arrays.asList ( //
                new BrowsePath ( Identifiers.ObjectsFolder, new RelativePath ( //
                        relativePaths ) ) //
        ) ).get ( 30, TimeUnit.SECONDS );

        final BrowsePathResult browsePathResult = response.getResults ()[0];
        final NodeId n = browsePathResult.getTargets ()[browsePathResult.getTargets ().length - 1].getTargetId ().local ().get ();
        return n;
    }
    catch ( final Exception e )
    {
        return null;
    }
}
 

private Variant convertValue ( final DataValue value, final Map<String, Variant> attributes )
{
    if ( ( value == null ) || ( value.getValue () == null ) || !value.getValue ().getDataType ().isPresent () )
    {
        return Variant.NULL;
    }
    final NodeId dataType = value.getValue ().getDataType ().get ();
    if ( Identifiers.DateTime.equals ( dataType ) )
    {
        final long ts = ( (DateTime)value.getValue ().getValue () ).getJavaDate ().getTime ();
        attributes.put ( "formatted", Variant.valueOf ( String.format ( "%s", ( (DateTime)value.getValue ().getValue () ) ) ) );
        return Variant.valueOf ( ts );
    }
    else if ( Identifiers.LocalizedText.equals ( dataType ) )
    {
        final String t = ( (LocalizedText)value.getValue ().getValue () ).getText ();
        attributes.put ( "formatted", Variant.valueOf ( String.format ( "%s", ( (LocalizedText)value.getValue ().getValue () ) ) ) );
        return Variant.valueOf ( t );
    }
    return Variant.valueOf ( value.getValue ().getValue () );
}
 

public static void main(final String[] args) throws Exception {

        final OpcUaClient client = Connect.connect().get();

        try {
            System.out.format("%-60s %-15s %s%n", "Name", "Type", "NodeID");
            System.out.println(
                    "==========================================================================================");
            browse(client, Identifiers.RootFolder, "");

        } finally {
            client.disconnect().get();
        }
    }
 

private BrowseDescription createBrowseDescription ( final NodeId nodeId )
{
    return new BrowseDescription ( nodeId, //
            BrowseDirection.Forward, //
            Identifiers.References, //
            true, //
            uint ( NodeClass.Object.getValue () | NodeClass.Variable.getValue () ), //
            uint ( BrowseResultMask.All.getValue () ) );
}
 

private void browseNodes() {
  LinkedHashMap<String, Field> rootFieldMap = new LinkedHashMap<>();
  Map<String, Boolean> visitedMap = new HashMap<>();
  browseNode(Identifiers.RootFolder, rootFieldMap, visitedMap);
  BatchContext batchContext = context.startBatch();
  String requestId = System.currentTimeMillis() + "." + counter.getAndIncrement();
  Record record = context.createRecord(requestId);
  record.set("/", Field.create(rootFieldMap));
  batchContext.getBatchMaker().addRecord(record);
  context.processBatch(batchContext);
}
 

public ExampleNamespace(OpcUaServer server, UShort namespaceIndex) {
    this.server = server;
    this.namespaceIndex = namespaceIndex;

    subscriptionModel = new SubscriptionModel(server, this);

    try {
        // Create a "HelloWorld" folder and add it to the node manager
        NodeId folderNodeId = new NodeId(namespaceIndex, "HelloWorld");

        UaFolderNode folderNode = new UaFolderNode(
            server.getNodeMap(),
            folderNodeId,
            new QualifiedName(namespaceIndex, "HelloWorld"),
            LocalizedText.english("HelloWorld")
        );

        server.getNodeMap().addNode(folderNode);

        // Make sure our new folder shows up under the server's Objects folder
        server.getUaNamespace().addReference(
            Identifiers.ObjectsFolder,
            Identifiers.Organizes,
            true,
            folderNodeId.expanded(),
            NodeClass.Object
        );

        // Add the rest of the nodes
        addVariableNodes(folderNode);

        addMethodNode(folderNode);
    } catch (UaException e) {
        logger.error("Error adding nodes: {}", e.getMessage(), e);
    }
}
 

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);
    }
}
 

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);
}
 

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);
}
 

private void addMethodNode(UaFolderNode folderNode) {
    UaMethodNode methodNode = UaMethodNode.builder(server.getNodeMap())
        .setNodeId(new NodeId(namespaceIndex, "HelloWorld/sqrt(x)"))
        .setBrowseName(new QualifiedName(namespaceIndex, "sqrt(x)"))
        .setDisplayName(new LocalizedText(null, "sqrt(x)"))
        .setDescription(
            LocalizedText.english("Returns the correctly rounded positive square root of a double value."))
        .build();


    try {
        AnnotationBasedInvocationHandler invocationHandler =
            AnnotationBasedInvocationHandler.fromAnnotatedObject(
                server.getNodeMap(), new SqrtMethod());

        methodNode.setProperty(UaMethodNode.InputArguments, invocationHandler.getInputArguments());
        methodNode.setProperty(UaMethodNode.OutputArguments, invocationHandler.getOutputArguments());
        methodNode.setInvocationHandler(invocationHandler);

        server.getNodeMap().addNode(methodNode);

        folderNode.addReference(new Reference(
            folderNode.getNodeId(),
            Identifiers.HasComponent,
            methodNode.getNodeId().expanded(),
            methodNode.getNodeClass(),
            true
        ));

        methodNode.addReference(new Reference(
            methodNode.getNodeId(),
            Identifiers.HasComponent,
            folderNode.getNodeId().expanded(),
            folderNode.getNodeClass(),
            false
        ));
    } catch (Exception e) {
        logger.error("Error creating sqrt() method.", e);
    }
}
 

public static void main(final String[] args) throws Exception {

        connect()

                .thenCompose(client -> {

                    return translate(client, Identifiers.ObjectsFolder, "1:LedState", "1:E_SR", "1:Q")

                            .thenAccept(Lookup::dumpResult)
                            .thenCompose(c -> client.disconnect());

                }) // .thenCompose

                .get();

    }
 

private void registerItems(final UaNodeContext context) {

        // create a folder

        final UaFolderNode folder = new UaFolderNode(
                context,
                newNodeId(1),
                newQualifiedName("FooBarFolder"),
                LocalizedText.english("Foo Bar Folder"));
        context.getNodeManager().addNode(folder);

        // add our folder to the objects folder

        final Optional<UaNode> objectsFolder = context.getServer()
                .getAddressSpaceManager()
                .getManagedNode(Identifiers.ObjectsFolder);

        objectsFolder.ifPresent(node -> {
            ((FolderNode) node).addComponent(folder);
        });

        // add single variable

        {
            final UaVariableNode variable = new UaVariableNode(
                    context,
                    newNodeId("look-at-me-i-am-right-here-hey-watch-out-woooohoo-here-i-am"),
                    newQualifiedName("FooBar"),
                    LocalizedText.english("Foo Bar")) {

                @Override
                public DataValue getValue() {
                    return new DataValue(new Variant(Math.sin(System.currentTimeMillis() / 1000)));
                }
            };

            variable.setDataType(Identifiers.Double);

            folder.addOrganizes(variable);
            context.getNodeManager().addNode(variable);
        }

        // add method call

        {
            final UaMethodNode method = createCallMeNode(
                    context,
                    newNodeId("call-me-al"),
                    newQualifiedName("Al"));
            folder.addComponent(method);
            context.getNodeManager().addNode(method);
        }
    }
 

public OpcRootTreeFolder ( final ItemManager itemManager, final String prefix )
{
    super ( itemManager, prefix, null, Identifiers.ObjectsFolder, Collections.emptyList () );
    logger.trace ( "constructor finished" );
}
 

private void browseNode(
    NodeId browseRoot,
    LinkedHashMap<String, Field> rootFieldMap,
    Map<String, Boolean> visitedMap
) {
  if (visitedMap.containsKey(browseRoot.getIdentifier().toString())) {
    return;
  }

  visitedMap.put(browseRoot.getIdentifier().toString(), true);

  BrowseDescription browse = new BrowseDescription(
      browseRoot,
      BrowseDirection.Forward,
      Identifiers.References,
      true,
      uint(NodeClass.Object.getValue() | NodeClass.Variable.getValue()),
      uint(BrowseResultMask.All.getValue())
  );

  try {
    BrowseResult browseResult = opcUaClient.browse(browse).get();
    List<ReferenceDescription> references = toList(browseResult.getReferences());

    for (ReferenceDescription rd : references) {
      if (visitedMap.containsKey(rd.getNodeId().getIdentifier().toString())) {
        continue;
      }
      LinkedHashMap<String, Field> fieldMap = new LinkedHashMap<>();
      fieldMap.put("name", Field.create(rd.getBrowseName().getName()));
      fieldMap.put("nameSpaceIndex", Field.create(rd.getNodeId().getNamespaceIndex().intValue()));
      fieldMap.put("identifierType", Field.create(rd.getNodeId().getType().name()));
      fieldMap.put("identifier", Field.create(rd.getNodeId().getIdentifier().toString()));

      // recursively browse to children
      rd.getNodeId().local().ifPresent(nodeId -> {
        if (!nodeId.equals(browseRoot)) {
          LinkedHashMap<String, Field> childrenMap = new LinkedHashMap<>();
          browseNode(nodeId, childrenMap, visitedMap);
          if (!childrenMap.isEmpty()) {
            fieldMap.put("children",  Field.create(childrenMap));
          }
        }
      });

      rootFieldMap.put(rd.getBrowseName().getName(), Field.create(fieldMap));
    }
  } catch (InterruptedException | ExecutionException ex) {
    LOG.error(Errors.OPC_UA_10.getMessage(), browseRoot, ex.getMessage(), ex);
    errorQueue.offer(new StageException(Errors.OPC_UA_10, browseRoot, ex.getMessage(), ex));
  }
}
 

private void addArrayNodes(UaFolderNode rootNode) {
    UaFolderNode arrayTypesFolder = new UaFolderNode(
        server.getNodeMap(),
        new NodeId(namespaceIndex, "HelloWorld/ArrayTypes"),
        new QualifiedName(namespaceIndex, "ArrayTypes"),
        LocalizedText.english("ArrayTypes")
    );

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

    for (Object[] os : STATIC_ARRAY_NODES) {
        String name = (String) os[0];
        NodeId typeId = (NodeId) os[1];
        Object value = os[2];
        Object array = Array.newInstance(value.getClass(), 4);
        for (int i = 0; i < 4; i++) {
            Array.set(array, i, value);
        }
        Variant variant = new Variant(array);

        UaVariableNode node = new UaVariableNode.UaVariableNodeBuilder(server.getNodeMap())
            .setNodeId(new NodeId(namespaceIndex, "HelloWorld/ArrayTypes/" + 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)
            .setValueRank(ValueRank.OneDimension.getValue())
            .setArrayDimensions(new UInteger[]{uint(0)})
            .build();

        node.setValue(new DataValue(variant));

        node.setAttributeDelegate(new ValueLoggingDelegate());

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