gio/auto/
memory_output_stream.rs

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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use crate::{ffi, OutputStream, PollableOutputStream, Seekable};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// `GMemoryOutputStream` is a class for using arbitrary
    /// memory chunks as output for GIO streaming output operations.
    ///
    /// As of GLib 2.34, `GMemoryOutputStream` trivially implements
    /// [`PollableOutputStream`][crate::PollableOutputStream]: it always polls as ready.
    ///
    /// ## Properties
    ///
    ///
    /// #### `data`
    ///  Pointer to buffer where data will be written.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `data-size`
    ///  Size of data written to the buffer.
    ///
    /// Readable
    ///
    ///
    /// #### `destroy-function`
    ///  Function called with the buffer as argument when the stream is destroyed.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `realloc-function`
    ///  Function with realloc semantics called to enlarge the buffer.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `size`
    ///  Current size of the data buffer.
    ///
    /// Readable | Writeable | Construct Only
    ///
    /// # Implements
    ///
    /// [`MemoryOutputStreamExt`][trait@crate::prelude::MemoryOutputStreamExt], [`OutputStreamExt`][trait@crate::prelude::OutputStreamExt], [`trait@glib::ObjectExt`], [`PollableOutputStreamExt`][trait@crate::prelude::PollableOutputStreamExt], [`SeekableExt`][trait@crate::prelude::SeekableExt], [`OutputStreamExtManual`][trait@crate::prelude::OutputStreamExtManual], [`PollableOutputStreamExtManual`][trait@crate::prelude::PollableOutputStreamExtManual]
    #[doc(alias = "GMemoryOutputStream")]
    pub struct MemoryOutputStream(Object<ffi::GMemoryOutputStream, ffi::GMemoryOutputStreamClass>) @extends OutputStream, @implements PollableOutputStream, Seekable;

    match fn {
        type_ => || ffi::g_memory_output_stream_get_type(),
    }
}

impl MemoryOutputStream {
    pub const NONE: Option<&'static MemoryOutputStream> = None;

    /// Creates a new #GMemoryOutputStream, using g_realloc() and g_free()
    /// for memory allocation.
    #[doc(alias = "g_memory_output_stream_new_resizable")]
    pub fn new_resizable() -> MemoryOutputStream {
        unsafe {
            OutputStream::from_glib_full(ffi::g_memory_output_stream_new_resizable()).unsafe_cast()
        }
    }
}

/// Trait containing all [`struct@MemoryOutputStream`] methods.
///
/// # Implementors
///
/// [`MemoryOutputStream`][struct@crate::MemoryOutputStream]
pub trait MemoryOutputStreamExt: IsA<MemoryOutputStream> + 'static {
    /// Returns the number of bytes from the start up to including the last
    /// byte written in the stream that has not been truncated away.
    ///
    /// # Returns
    ///
    /// the number of bytes written to the stream
    #[doc(alias = "g_memory_output_stream_get_data_size")]
    #[doc(alias = "get_data_size")]
    #[doc(alias = "data-size")]
    fn data_size(&self) -> usize {
        unsafe { ffi::g_memory_output_stream_get_data_size(self.as_ref().to_glib_none().0) }
    }

    /// Returns data from the @self as a #GBytes. @self must be
    /// closed before calling this function.
    ///
    /// # Returns
    ///
    /// the stream's data
    #[doc(alias = "g_memory_output_stream_steal_as_bytes")]
    fn steal_as_bytes(&self) -> glib::Bytes {
        unsafe {
            from_glib_full(ffi::g_memory_output_stream_steal_as_bytes(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "data-size")]
    fn connect_data_size_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_data_size_trampoline<
            P: IsA<MemoryOutputStream>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GMemoryOutputStream,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(MemoryOutputStream::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::data-size\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_data_size_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<MemoryOutputStream>> MemoryOutputStreamExt for O {}