nu-utils 0.115.0

Nushell utility functions
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

use std::{cell::RefCell, fmt, rc::Rc};

/// A cloneable handle to a single-threaded [`fmt`] writer.
///  
/// Clones of this handle write to the same underlying writer.
/// This type uses interior mutability and is not thread-safe, i.e. it is not [Send] nor [Sync].
///
/// # Example
///
/// ```rust
/// use std::fmt::Write;
/// use nu_utils::FmtHandle;
///
/// let mut string = String::new();
/// let mut a = FmtHandle::new(&mut string);
/// let mut b = a.clone();
/// a.write_str("abc").unwrap();
/// b.write_str("def").unwrap();
/// drop(a);
/// drop(b);
///
/// assert_eq!(string, "abcdef");
/// ```
#[derive(Debug)]
pub struct FmtHandle<W>(Rc<RefCell<W>>);

impl<W> FmtHandle<W> {
    pub fn new(writer: W) -> Self {
        Self(Rc::new(RefCell::new(writer)))
    }
}

impl<W: Default> FmtHandle<W> {
    pub fn take(&self) -> W {
        self.0.take()
    }
}

impl<W> Clone for FmtHandle<W> {
    fn clone(&self) -> Self {
        Self(self.0.clone())
    }
}

impl<W: fmt::Write> fmt::Write for FmtHandle<W> {
    fn write_str(&mut self, s: &str) -> fmt::Result {
        self.0.borrow_mut().write_str(s)
    }
}