Merge branch 'main' of https://github.com/PacktPublishing/Asynchronous-Programming-in-Rust

Author: cfsamson

ch10/x-pin-experiments/src/main.exe

@@ -1,108 +1,45 @@
-// fn main() {
-//     let list1: Vec<SelfRef> = (0..10).map(|_| {
-//         let mut picker = SelfRef::new();
-//         picker.pick(2);
-//         picker
-//     }).collect();
+use std::{marker::PhantomPinned, pin::Pin};
 
-//     list1.iter().for_each(|p| println!("{}", p.show()));
+// use std::pin::pin;
+// fn main() {
+//     let mut x = pin!(MaybeSelfRef::default());
+//     MaybeSelfRef::init(x.as_mut());
+//     println!("{:?}", x.as_ref().b());
+// }
 
-//     let list2 = Vec::from_iter(list1.iter());
-//     list2.iter().for_each(|p| println!("{}", p.show()));
+// // Pinning stack
+// fn main() {
+//     let mut x = MaybeSelfRef::default();
+//     let mut x = unsafe { Pin::new_unchecked(&mut x) };
+//     MaybeSelfRef::init(x.as_mut());
+//     println!("{:?}", x.as_ref().b());
 // }
+
 fn main() {
-    let mut picker1 = Picker::new();
-    picker1.pick(2);
-    println!("{}", picker1.show());
-    let replaced = std::mem::replace(&mut picker1, Picker::new());
-    println!("{}", replaced.show());
+    let mut x = Box::pin(MaybeSelfRef::default());
+    x.as_mut().init();
+    let b = x.as_mut().b().unwrap();
+    println!("{}", b);
+    *b = 2;
+    println!("{x:?}");
 }
 
-#[derive(Clone, Default)]
-struct Picker {
-    numbers: Option<[usize; 3]>,
-    picked: Option<*const usize>,
+#[derive(Default, Debug)]
+struct MaybeSelfRef {
+    a: usize,
+    b: Option<*mut usize>,
+    _pin: PhantomPinned,
 }
 
-impl Picker {
-    fn new() -> Self {
-        Picker {
-            numbers: None,
-            picked: None,
+impl MaybeSelfRef {
+    fn init(self: Pin<&mut Self>) {
+        unsafe {
+            let Self { a, b, .. } = self.get_unchecked_mut();
+            *b = Some(a);
         }
     }
 
-    fn pick(&mut self, n: usize) {
-        self.numbers = Some([1, 2, 3]);
-        self.picked = Some(&self.numbers.as_ref().unwrap()[n]);
-    }
-
-    fn show(&self) -> String {
-        match self.picked {
-            Some(p) => format!("Pick: {}", unsafe {*p}),
-            None => format!("Nothing picked yet"),
-        }
+    fn b(self: Pin<&mut Self>) -> Option<&mut usize> {
+        unsafe { self.get_unchecked_mut().b.map(|b| &mut *b) }
     }
 }
-
-// fn main() {
-//     let code_table = ['d','h','e','x','l','w','p','y','z'];
-
-//     let mut selfref = SelfRef {
-//         code_table,
-//         encoder: Encoder::new(),
-//     };
-
-//     selfref.encoder.set(&selfref.code_table);
-
-//     selfref.encoder.encode(&[1,2,3,2,3,4,5,2]);
-//     println!("{}", selfref.encoder.txt);
-// }
-
-// struct SelfRef<'a> {
-//     code_table: [char; 9],
-//     encoder: Encoder<'a>,
-// }
-
-// struct Encoder<'a> {
-//     code_table: Option<&'a [char; 9]>,
-//     txt: String,
-// }
-
-// impl<'a> Encoder<'a> {
-//     fn new() -> Self {
-//         Encoder { code_table: None, txt: String::new() }
-//     }
-//     fn set(&mut self, code_table: &'a [char; 9]) {
-//         self.code_table = Some(code_table);
-//     }
-//     fn encode(&mut self, numbers: &[usize]) {
-//         let table = self.code_table.expect("Not set");
-//         for num in numbers {
-//             self.txt.push(table[*num]);
-//         }
-//     }
-// }
-
-// struct SecretFmt<'a> {
-//     random: &'a String,
-//     something_big: Vec<u8>,
-// }
-
-// impl<'a> SecretFmt<'a> {
-//     fn new(random: &'a String) -> Self {
-//         Self {
-//             random,
-//             something_big: vec![0u8; 1024 * 1000 * 1000],
-//         }
-//     }
-
-//     fn fmt(&self, txt: &str) -> String {
-//         format!("{}: {}", self.random, txt)
-//     }
-// }
-
-// struct MyFormatter<'a> {
-//     data: String,
-//     formatter: SecretFmt<'a>,
-// }