Trait const_format::marker_traits::WriteMarker

source · [−]

pub trait WriteMarker {
    type Kind;
    type This: ?Sized;
}

Available on crate feature fmt only.

Expand description

Marker trait for types that can be written into.

Implementors

Types that implement this trait are also expected to implement these inherent methods:

// use const_format::{FormattingFlags, Formatter};

const fn borrow_mutably(&mut self) -> &mut Self
const fn make_formatter(&mut self, flags: FormattingFlags) -> Formatter<'_>

Coercions

The Kind and This associated types are used in the IsAWriteMarker marker type to convert a &mut StrWriter<_> to a StrWriterMut<'_>, and leave other mutable references unconverted.

Example

Implementing this trait for a String-like inline allocated type.

#![feature(const_mut_refs)]

use const_format::marker_traits::{IsNotAStrWriter, WriteMarker};
use const_format::{Formatter, FormattingFlags};
use const_format::writec;

mod arraystring {
    use const_format::marker_traits::{IsNotAStrWriter, WriteMarker};
    use const_format::{Formatter, FormattingFlags};

    const ARRAY_CAP: usize = 64;
    pub struct ArrayString  {
        len: usize,
        arr: [u8; ARRAY_CAP],
    }
    
    impl WriteMarker for ArrayString  {
        type Kind = IsNotAStrWriter;
        type This = Self;
    }
    
    impl ArrayString {
        pub const fn new() -> Self {
            Self { len: 0, arr: [0; ARRAY_CAP] }
        }
         
        // Gets the part of the array that has been written to.
        pub const fn as_bytes(&self) -> &[u8] {
            const_format::utils::slice_up_to_len_alt(&self.arr, self.len)
        }
    
        pub const fn borrow_mutably(&mut self) -> &mut Self {
            self
        }
    
        pub const fn make_formatter(&mut self, flags: FormattingFlags) -> Formatter<'_> {
            Formatter::from_custom(&mut self.arr, &mut self.len, flags)
        }
    }
}
use arraystring::ArrayString;


let mut buffer = ArrayString::new();

writec!(buffer, "{:?}", [3u8, 5])?;
assert_eq!(buffer.as_bytes(), b"[3, 5]");

writec!(buffer, "{}{:b}", "Hello, world!", 100u16)?;
assert_eq!(buffer.as_bytes(), b"[3, 5]Hello, world!1100100");