-1

i am trying to make a simple tauri Program where i have a Filetree of all Files and sub files of a chosen directory. I have not got many experience in Rust and ran into a problem with Ownerships.

Code

use std::fs;
use std::path::PathBuf;
use trees::Tree;

//FileTree
//https://docs.rs/crate/file_tree/0.1.1
fn main() {
    let path = PathBuf::from("MyPath...");
    let tree = Tree::new(path);
    
    build_tree(tree);
}

fn build_tree( mut tree:Tree<PathBuf>){
    
    let path = tree.front().unwrap().data();
    for entry in fs::read_dir(path).unwrap() {
        let entry = entry.unwrap();
        let subpath = entry.path();
        if subpath.is_dir() {
            let subtree = Tree::new(subpath);
            build_tree(subtree);
            tree.push_back(subtree);
        } else {
            tree.push_back(Tree::new(subpath));
        }
    }
    tree;
}

This is what i figured out so far but in the line: tree.push_back(subtree);

I got following Error

error[E0382]: use of moved value: subtree

  --> src\main.rs:23:28
   |
21 |             let subtree = Tree::new(subpath);
   |                 ------- move occurs because `subtree` has type `trees::Tree<PathBuf>`, which does not implement the `Copy` trait
22 |             build_tree(subtree);
   |                        ------- value moved here
23 |             tree.push_back(subtree);
   |                            ^^^^^^^ value used here after move

What i tried

I tried to make subtree mutable but it didn't work either because it says mut is not necessary

Also i already tried to use the Filetree crate of Rust but it was not exectely what i was looking for.

Someone got other Ideas how to Implement a Filetree in Rust or Tauri?

DaKoller
  • 11
  • 3
  • Please post the full error from `cargo check`, not from your IDE. – Chayim Friedman Jun 16 '22 at 12:43
  • It looks like you are in-between two different implementations, the `tree;` at the end looks like you want to return the tree you build to the calling function, but the way your function takes a `mut tree` looks like you intended to pass a variable by reference and mutate it. Is there one of those methods (return vs mutate) that you'd prefer to use? – Jeremy Meadows Jun 16 '22 at 13:17
  • Hi thanks for responding. I prefer mut but i guess in this case return would be easier right? – DaKoller Jun 16 '22 at 13:28
  • I don't really think one is "easier" than another. I generally prefer mut too, unless I want method chaining like a Builder pattern or something. – Jeremy Meadows Jun 16 '22 at 13:40

1 Answers1

1

You are trying to mutate a tree in your build_tree function, but since the function is taking ownership of whatever you pass in, you get the value used here after move error afterwards. To allow a function to mutate a variable and the variable still exist afterwards, you should instead pass in a mutable reference to the tree:

use std::fs;
use std::path::PathBuf;
use trees::Tree;

fn main() {
    let path = PathBuf::from("MyPath...");
    let mut tree = Tree::new(path);
    
    build_tree(&mut tree);
}

fn build_tree(tree: &mut Tree<PathBuf>) {
    let path = tree.front().unwrap().data();

    for entry in fs::read_dir(path).unwrap() {
        let entry = entry.unwrap();
        let subpath = entry.path();

        if subpath.is_dir() {
            let mut subtree = Tree::new(subpath);
            build_tree(&mut subtree);
            tree.push_back(subtree);
        } else {
            tree.push_back(Tree::new(subpath));
        }
    }
}

Notice also that you need to change some variable declarations to use let mut so that the compiler allows a mutable reference (&mut) to that variable to be used.

This can also be done by taking ownership and returning a new value, but this method looks a little closer to what you had originally.

Jeremy Meadows
  • 2,314
  • 1
  • 6
  • 22