从保留或引用中获取所有权

huangapple
go评论109阅读模式
英文:

Take Ownership from retain or reference

问题

我正在编写一个Rust解析器玩具，并且想要转换一些节点，有三种可能的转换操作：删除、保留和ToTopLevel。删除和保留是可以的，但当我遇到ToTopLevel时，我需要克隆一个节点并将其推送到临时的Vec中，因为它将删除节点，我想知道是否有办法获取所有权并将其直接传递给临时的Vec。

  1. use std::borrow::Cow;
  2. #[derive(PartialEq, Clone)]
  3. struct ASTNode<'a> {
  4.     value: Cow<'a, str>,
  5.     nodes: Vec<ASTNode<'a>>
  6. }
  7. struct Visitor<'a> {
  8.     new_node: Vec<ASTNode<'a>>
  9. }
  11. enum Action {
  12.     Remove,
  13.     Keep,
  14.     ToTopLevel,
  15. }
  17. impl<'a> Visitor<'a> {
  18.     fn some_compute_to_determinate_action(&mut self, root: &mut ASTNode<'a>) -> Action {
  19.         return Action::ToTopLevel;
  20.     }
  21.     fn visit(&mut self, root: &mut ASTNode<'a>) -> Action {
  22.         let mut children_actions: Vec<Action> = Vec::new();
  23.         for node in &mut root.nodes {
  24.             children_actions.push(self.visit(node));
  25.         }
  26.         let mut index: usize = 0;
  27.         root.nodes.retain(|node| {
  28.             index += 1;
  29.             match children_actions[index - 1] {
  30.                 Action::Remove => false,
  31.                 Action::Keep => true,
  32.                 Action::ToTopLevel => {
  33.                     // 由于它将删除节点，是否有办法获取所有权并将其推送到new_node vec中？
  34.                     // 类似于：self.new_node.push(*node);
  35.                     self.new_node.push(node.clone());
  36.                     return false;
  37.                 }
  38.             }
  39.         });
  40.         return self.some_compute_to_determinate_action(root);
  41.     }
  42.     fn push_node_to_top_level_after_visit(&mut self, root: &mut ASTNode<'a>) {
  43.         root.nodes.append(&mut self.new_node);
  44.     }
  45. }
  46. fn main() {
  47.     let mut root = ASTNode {
  48.         value: Cow::Borrowed("root_value"),
  49.         nodes: Vec::new()/* 假设有许多嵌套的子节点 */
  50.     };
  51.     let mut visitor = Visitor {
  52.         new_node: Vec::new()
  53.     };
  54.     visitor.visit(&mut root);
  55.     visitor.push_node_to_top_level_after_visit(&mut root);
  56. }
英文:

I am writing a Rust parser toy, and I want to transform some nodes, there are three possible for this transform remove, keep, ToTopLevel, remove and keep is ok, but when I encounter ToTopLevel, I need to clone a node to push it into a temporary Vec, since it will delete node I wonder if there is any way I can get ownership and just give it to the temporary Vec.

  1. use std::borrow::Cow;
  2. #[derive(PartialEq, Clone)]
  3. struct ASTNode&lt;&#39;a&gt; {
  4.     value: Cow&lt;&#39;a, str&gt;,
  5.     nodes: Vec&lt;ASTNode&lt;&#39;a&gt;&gt;
  6. }
  7. struct Visitor&lt;&#39;a&gt; {
  8.     new_node: Vec&lt;ASTNode&lt;&#39;a&gt;&gt;
  9. }
  11. enum Action {
  12.     Remove,
  13.     Keep,
  14.     ToTopLevel,
  15. }
  17. impl&lt;&#39;a&gt; Visitor&lt;&#39;a&gt; {
  18.     fn some_compute_to_determinate_action(&amp;mut self, root: &amp;mut ASTNode&lt;&#39;a&gt;) -&gt; Action {
  19.         return Action::ToTopLevel;
  20.     }
  21.     fn visit(&amp;mut self, root :&amp;mut ASTNode&lt;&#39;a&gt;) -&gt; Action {
  22.         let mut children_actions: Vec&lt;Action&gt; = Vec::new();
  23.         for node in &amp;mut root.nodes {
  24.             children_actions.push(self.visit(node));
  25.         }
  26.         let mut index: usize = 0;
  27.         root.nodes.retain(|node| {
  28.             index+=1;
  29.             match children_actions[index-1] {
  30.                 Action::Remove =&gt; false,
  31.                 Action::Keep =&gt; true,
  32.                 Action::ToTopLevel =&gt; {
  33.                     // since it would delete node, is there are any way
  34.                     // i can take ownership and push it to new_node vec ?
  35.                     // like : self.new_node.push(*node);
  36.                     self.new_node.push(node.clone());
  37.                     return false;
  38.                 }
  39.             }
  40.         });
  41.         return self.some_compute_to_determinate_action(root);
  42.     }
  43.     fn push_node_to_top_level_after_visit(&amp;mut self,root: &amp;mut ASTNode&lt;&#39;a&gt;) {
  44.         root.nodes.append(&amp;mut self.new_node);
  45.     }
  46. }
  47. fn main() {
  48.     let mut root = ASTNode {
  49.         value: Cow::Borrowed(&quot;root_value&quot;),
  50.         nodes: Vec::new()/*  assume there are a a lot of nested children  */
  51.     };
  52.     let mut visitor = Visitor {
  53.         new_node: Vec::new()
  54.     };
  55.     visitor.visit(&amp;mut root);
  56.     visitor.push_node_to_top_level_after_visit(&amp;mut root);
  57. }

答案1

得分: 1

以下是翻译好的部分：

"However since it's possible to create an ASTNode cheaply:

  1. ASTNode {
  2. value: Cow::Borrowed(""),
  3. nodes: Vec::new()
  4. }

what you can do is use Vec::retain_mut and std::mem::replace to take the "actual" ASTNode out replacing it with a dummy which you then don't keep:

  1.     root.nodes.retain_mut(|node| {
  2. index+=1;
  3. match children_actions[index-1] {
  4. Action::Remove => false,
  5. Action::Keep => true,
  6. Action::ToTopLevel => {
  7. self.new_node.push(std::mem::replace(node, ASTNode {
  8. value: Cow::Borrowed(""),
  9. nodes: Vec::new(),
  10. }));
  11. false
  12. }
  13. }
  14. });

or if you derive(Default) on ASTNode, just std::mem::take

  1.     root.nodes.retain_mut(|node| {
  2. index+=1;
  3. match children_actions[index-1] {
  4. Action::Remove => false,
  5. Action::Keep => true,
  6. Action::ToTopLevel => {
  7. self.new_node.push(std::mem::take(node));
  8. false
  9. }
  10. }
  11. });"
英文:

There is no iterator or method which hands off the item itself (it'd need something like T -&gt; Option&lt;T&gt; as a callback, not sure why there isn't such a variant for drain and retain though, seems useful).

However since it's possible to create an ASTNode cheaply:

  1. ASTNode {
  2. value: Cow::Borrowed(&quot;&quot;),
  3. nodes: Vec::new()
  4. }

what you can do is use Vec::retain_mut and std::mem::replace to take the "actual" ASTNode out replacing it with a dummy which you then don't keep:

  1.     root.nodes.retain_mut(|node| {
  2. index+=1;
  3. match children_actions[index-1] {
  4. Action::Remove =&gt; false,
  5. Action::Keep =&gt; true,
  6. Action::ToTopLevel =&gt; {
  7. self.new_node.push(std::mem::replace(node, ASTNode {
  8. value: Cow::Borrowed(&quot;&quot;),
  9. nodes: Vec::new(),
  10. }));
  11. false
  12. }
  13. }
  14. });

or if you derive(Default) on ASTNode, just std::mem::take

  1.     root.nodes.retain_mut(|node| {
  2. index+=1;
  3. match children_actions[index-1] {
  4. Action::Remove =&gt; false,
  5. Action::Keep =&gt; true,
  6. Action::ToTopLevel =&gt; {
  7. self.new_node.push(std::mem::take(node));
  8. false
  9. }
  10. }
  11. });

huangapple
  • 本文由 发表于 2023年7月23日 23:00:09
  • 转载请务必保留本文链接：https://go.coder-hub.com/76748915.html
  • ownership
  • reference
  • rust
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定