libyaml 0.1.0

High-level bindings for the LibYAML library
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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

use std::io;
use std::mem;
use std::os::raw;
use std::slice;

use libyaml_sys as sys;

use crate::{EmitterError, Event};

/// Emitter.
pub struct Emitter<'a> {
    inner: sys::yaml_emitter_t,
    writer: Box<dyn io::Write + 'a>,
    writer_error: Option<io::Error>,
}

impl<'a> Emitter<'a> {
    /// Create an emitter with default configuration.
    ///
    /// If a custom configuration is needed, use [`EmitterBuilder`] to build an
    /// `Emitter` instance.
    ///
    /// [`EmitterBuilder`]: struct.EmitterBuilder.html
    pub fn new<W: io::Write + 'a>(writer: W) -> Result<Box<Self>, EmitterError> {
        let mut inner = unsafe { mem::MaybeUninit::zeroed().assume_init() };

        if unsafe { sys::yaml_emitter_initialize(&mut inner) } == 1 {
            let mut emitter = Box::new(Self {
                inner,
                writer: Box::new(writer),
                writer_error: None,
            });

            unsafe {
                sys::yaml_emitter_set_output(
                    &mut emitter.inner,
                    Some(write_handler),
                    emitter.as_mut() as *mut _ as *mut _,
                );
            }

            Ok(emitter)
        } else {
            Err(EmitterError::LibYamlError)
        }
    }

    /// Emit an event.
    pub fn emit(&mut self, event: Event) -> Result<(), EmitterError> {
        if unsafe { sys::yaml_emitter_emit(&mut self.inner, &mut event.into_raw()?) } == 1 {
            debug_assert!(self.writer_error.is_none());
            Ok(())
        } else {
            match mem::replace(&mut self.writer_error, None) {
                Some(e) => Err(EmitterError::IoError(e)),
                None => Err(EmitterError::LibYamlError),
            }
        }
    }

    /// Flush the emitter buffer to writer.
    pub fn flush(&mut self) -> Result<(), EmitterError> {
        if unsafe { sys::yaml_emitter_flush(&mut self.inner) } == 1 {
            Ok(())
        } else {
            Err(EmitterError::LibYamlError)
        }
    }

    /// Return raw pointer to the underlying `yaml_emitter_t`.
    pub fn as_raw_ptr(&mut self) -> *mut sys::yaml_emitter_t {
        &mut self.inner
    }
}

impl Drop for Emitter<'_> {
    fn drop(&mut self) {
        unsafe {
            sys::yaml_emitter_delete(&mut self.inner)
        }
    }
}

unsafe extern fn write_handler(
    data: *mut raw::c_void,
    buffer: *mut raw::c_uchar,
    size: usize,
) -> raw::c_int {
    let emitter = &mut *(data as *mut Emitter);

    emitter.writer_error = emitter.writer
        .write_all(slice::from_raw_parts(buffer, size))
        .err();

    if emitter.writer_error.is_none() { 1 } else { 0 }
}