Data Providers (Flow)

class FolderDataProvider implements AbstractHierarchicalDataProvider<Folder, Void> {
    public FolderTreeData folderTreeData = new FolderTreeData();

    @Override
    public boolean isInMemory() {
        // Indicate that this data provider uses an in-memory data source.
        return true;
    }

    @Override
    public HierarchyFormat getHierarchyFormat() {
        // Indicate that this data provider uses the flattened hierarchy format.
        return HierarchyFormat.FLATTENED;
    }

    @Override
    public boolean hasChildren(Folder folder) {
        // Return whether the given folder has child folders.
        return folderTreeData.getChildren(folder).size() > 0;
    }

    @Override
    public Stream<Folder> fetchChildren(HierarchicalQuery<Folder, Void> query) {
        // Return the flattened sub-tree of the requested parent folder based on
        // the expanded folders.
        return flatten(query.getParent(), query.getExpandedItemIds())
                .skip(query.getOffset()).limit(query.getLimit());
    }

    @Override
    public int getChildCount(HierarchicalQuery<Folder, Void> query) {
        // Return the size of the flattened sub-tree of the requested parent
        // folder based on the expanded folders.
        return (int) flatten(query.getParent(), query.getExpandedItemIds())
                .count();
    }

    @Override
    public int getDepth(Folder folder) {
        // Return the depth of the given folder in the hierarchy for Tree Grid
        // to apply the correct indentation.
        int depth = 0;
        while ((folder = folderTreeData.getParent(folder)) != null) {
            depth++;
        }
        return depth;
    }

    private Stream<Folder> flatten(Folder parent,
            Set<Object> expandedFolderIds) {
        // Build the parent folder's sub-tree based on the provided expanded
        // folders. The result is a flat stream of folders in depth-first order.
        // Filtering and sorting can also be applied here if needed. Keep in
        // mind that sorting must be applied to each hierarchy level separately
        // to preserve depth-first order in the final flat list.
        return folderTreeData.getChildren(parent).stream().flatMap(child -> {
            if (expandedFolderIds.contains(getId(child))) {
                return Stream.concat(Stream.of(child),
                        flatten(child, expandedFolderIds));
            } else {
                return Stream.of(child);
            }
        });
    }
}

public class FolderTreeData extends TreeData<Folder> {
    public FolderTreeData() {
        // Creates a TreeData object with the following folder hierarchy:
        //
        // ├── Work
        // │ └── Documents
        // │ └── Invoices
        // └── Family

        Folder work = new Folder("Work");
        Folder documents = new Folder("Documents");
        Folder invoices = new Folder("Invoices");
        Folder family = new Folder("Family");

        addRootItems(work, family);
        addItem(work, documents);
        addItem(documents, invoices);
    }
}

public record Folder(String name) {};