Struct DiplomatWriteable 

#[repr(C)]
pub struct DiplomatWriteable { /* private fields */ }

An object that can one can write UTF-8 strings to

This allows the C API to write to arbitrary kinds of objects, for example a C++ std::string or a char buffer.

The way to use this object is to fill out the buf, len, cap fields with appropriate values for the buffer, its current length, and its current capacity, and flush and grow with appropriate callbacks (using context to reference any state they need). This object will be passed by mutable reference to the Rust side, and Rust will write to it, calling grow() as necessary. Once done, it will call flush() to update any state on context (e.g. adding a null terminator, updating the length). The object on the foreign side will be directly usable after this, the foreign side need not perform additional state updates after passing an DiplomatWriteable to a function.

[diplomat_simple_writeable()] can be used to write to a fixed-size char buffer.

May be extended in the future to support further invariants

DiplomatWriteable will not perform any cleanup on context or buf, these are logically “borrows” from the FFI side.

Safety invariants:

• flush() and grow() will be passed self including context and it should always be safe to do so. context may be null, however flush() and grow() must then be ready to receive it as such.
• buf must be cap bytes long
• grow() must either return false or update buf and cap for a valid buffer of at least the requested buffer size
• DiplomatWriteable::flush() will be automatically called by Diplomat. flush() might also be called (erroneously) on the Rust side (it’s a public method), so it must be idempotent.

Implementations

impl DiplomatWriteable

pub fn flush(&mut self)

Call this function before releasing the buffer to C

Trait Implementations

impl Write for DiplomatWriteable

fn write_str(&mut self, s: &str) -> Result<(), Error>

Writes a string slice into this writer, returning whether the write succeeded.

fn write_char(&mut self, c: char) -> Result<(), Error>

Writes a char into this writer, returning whether the write succeeded.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Glue for usage of the write! macro with implementors of this trait.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 48 bytes