Trait const_format::marker_traits::WriteMarker

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

This is supported on crate feature fmt only.

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");

Associated Types

type Kind

Whether this is a StrWriter or not, this can be either of IsAStrWriter or IsNotAStrWriter

type This: ?Sized

The type after dereferencing, implemented as type This = Self; for all non-reference types

Loading content...

Implementors

impl WriteMarker for Formatter<'_>

type Kind = IsNotAStrWriter

type This = Self

impl WriteMarker for StrWriterMut<'_>

type Kind = IsNotAStrWriter

type This = Self

impl<T: ?Sized> WriteMarker for &T where
    T: WriteMarker, 

type Kind = T::Kind

type This = T::This

impl<T: ?Sized> WriteMarker for &mut T where
    T: WriteMarker, 

type Kind = T::Kind

type This = T::This

impl<T: ?Sized> WriteMarker for StrWriter<T>

type Kind = IsAStrWriter

type This = Self

Loading content...