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
138
139

// This file was generated by gir (https://github.com/gtk-rs/gir @ fe7a6ff+)
// from gir-files (https://github.com/gtk-rs/gir-files @ b215ee8)
// DO NOT EDIT

use ContentEncoding;
use Stream;
use ffi;
use glib::object::IsA;
use glib::translate::*;
use glib_ffi;
use gobject_ffi;
use std::mem;
use std::ptr;

glib_wrapper! {
    /// A wrapper for a stream which may be encoded.
    ///
    /// # Implements
    ///
    /// [`DataWrapperExt`](trait.DataWrapperExt.html)
    pub struct DataWrapper(Object<ffi::GMimeDataWrapper, ffi::GMimeDataWrapperClass>);

    match fn {
        get_type => || ffi::g_mime_data_wrapper_get_type(),
    }
}

impl DataWrapper {
    /// Creates a new `DataWrapper` object.
    ///
    /// # Returns
    ///
    /// a new data wrapper object.
    pub fn new() -> DataWrapper {
        unsafe {
            from_glib_full(ffi::g_mime_data_wrapper_new())
        }
    }

    /// Creates a new `DataWrapper` object around `stream`.
    /// ## `stream`
    /// a `Stream`
    /// ## `encoding`
    /// stream's encoding
    ///
    /// # Returns
    ///
    /// a data wrapper around `stream`. Since the wrapper owns its
    /// own reference on the stream, caller is responsible for unrefing
    /// its own copy.
    pub fn new_with_stream<P: IsA<Stream>>(stream: &P, encoding: ContentEncoding) -> DataWrapper {
        unsafe {
            from_glib_full(ffi::g_mime_data_wrapper_new_with_stream(stream.to_glib_none().0, encoding.to_glib()))
        }
    }
}

impl Default for DataWrapper {
    fn default() -> Self {
        Self::new()
    }
}

/// Trait containing all `DataWrapper` methods.
///
/// # Implementors
///
/// [`DataWrapper`](struct.DataWrapper.html)
pub trait DataWrapperExt {
    /// Gets the encoding type of the stream wrapped by `self`.
    ///
    /// # Returns
    ///
    /// the encoding type of the internal stream.
    fn get_encoding(&self) -> ContentEncoding;

    /// Gets a reference to the stream wrapped by `self`.
    ///
    /// # Returns
    ///
    /// a reference to the internal stream.
    fn get_stream(&self) -> Option<Stream>;

    /// Sets the encoding type of the internal stream.
    /// ## `encoding`
    /// encoding
    fn set_encoding(&self, encoding: ContentEncoding);

    /// Replaces the wrapper's internal stream with `stream`. Don't forget,
    /// if `stream` is not of the same encoding as the old stream, you'll
    /// want to call `DataWrapperExt::set_encoding` as well.
    ///
    /// Note: caller is responsible for its own reference on
    /// `stream`.
    /// ## `stream`
    /// a `Stream`
    fn set_stream<P: IsA<Stream>>(&self, stream: &P);

    /// Writes the raw (decoded) data to the output stream.
    /// ## `stream`
    /// output stream
    ///
    /// # Returns
    ///
    /// the number of bytes written or %-1 on failure.
    fn write_to_stream<P: IsA<Stream>>(&self, stream: &P) -> isize;
}

impl<O: IsA<DataWrapper>> DataWrapperExt for O {
    fn get_encoding(&self) -> ContentEncoding {
        unsafe {
            from_glib(ffi::g_mime_data_wrapper_get_encoding(self.to_glib_none().0))
        }
    }

    fn get_stream(&self) -> Option<Stream> {
        unsafe {
            from_glib_none(ffi::g_mime_data_wrapper_get_stream(self.to_glib_none().0))
        }
    }

    fn set_encoding(&self, encoding: ContentEncoding) {
        unsafe {
            ffi::g_mime_data_wrapper_set_encoding(self.to_glib_none().0, encoding.to_glib());
        }
    }

    fn set_stream<P: IsA<Stream>>(&self, stream: &P) {
        unsafe {
            ffi::g_mime_data_wrapper_set_stream(self.to_glib_none().0, stream.to_glib_none().0);
        }
    }

    fn write_to_stream<P: IsA<Stream>>(&self, stream: &P) -> isize {
        unsafe {
            ffi::g_mime_data_wrapper_write_to_stream(self.to_glib_none().0, stream.to_glib_none().0)
        }
    }
}