[−][src]Trait const_format::marker_traits::WriteMarker

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

Marker trait for types that can be written into.

Implementors

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

ⓘThis example is not tested
// 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...

Implementations on Foreign Types

impl<T: ?Sized, '_> WriteMarker for &'_ T where
    T: WriteMarker, [src]

type Kind = T::Kind

type This = T::This

impl<T: ?Sized, '_> WriteMarker for &'_ mut T where
    T: WriteMarker, [src]

type Kind = T::Kind

type This = T::This

Loading content...

Implementors

impl<'_> WriteMarker for Formatter<'_>[src]

type Kind = IsNotAStrWriter

type This = Self

impl<'_> WriteMarker for StrWriterMut<'_>[src]

type Kind = IsNotAStrWriter

type This = Self

impl<T: ?Sized> WriteMarker for StrWriter<T>[src]

type Kind = IsAStrWriter

type This = Self

Loading content...