Struct soup::MessageBody

pub struct MessageBody { /* private fields */ }

#SoupMessageBody represents the request or response body of a Message.

Note that while @length always reflects the full length of the message body, @data is normally None, and will only be filled in after flatten() is called. For client-side messages, this automatically happens for the response body after it has been fully read. Likewise, for server-side messages, the request body is automatically filled in after being read.

As an added bonus, when @data is filled in, it is always terminated with a \0 byte (which is not reflected in @length).

Implementations

impl MessageBody

pub fn as_ptr(&self) -> *mut SoupMessageBody

Return the inner pointer to the underlying C value.

pub unsafe fn from_glib_ptr_borrow<'a>( ptr: *const *const SoupMessageBody ) -> &'a Self

Borrows the underlying C value.

impl MessageBody

pub fn new() -> MessageBody

Creates a new #SoupMessageBody.

Message uses this internally; you will not normally need to call it yourself.

Returns

a new #SoupMessageBody.

pub fn append_bytes(&self, buffer: &Bytes)

Appends the data from @buffer to @self.

buffer

a #GBytes

pub fn append_take(&self, data: &[u8])

Appends @length bytes from @data to @self.

This function is exactly equivalent to MessageBody::append() with MemoryUse::Take as second argument; it exists mainly for convenience and simplifying language bindings.

data

data to append

pub fn complete(&self)

Tags @self as being complete.

Call this when using chunked encoding after you have appended the last chunk.

pub fn flatten(&self) -> Option<Bytes>

Fills in @self’s data field with a buffer containing all of the data in @self.

Adds an additional \0 byte not counted by @self’s length field.

Returns

a #GBytes containing the same data as @self. (You must GLib::Bytes::unref() this if you do not want it.)

pub fn is_accumulate(&self) -> bool

Gets the accumulate flag on @self.

See set_accumulate(). for details.

Returns

the accumulate flag for @self.

pub fn chunk(&self, offset: i64) -> Option<Bytes>

Gets a glib::Bytes containing data from @self starting at @offset.

The size of the returned chunk is unspecified. You can iterate through the entire body by first calling chunk() with an offset of 0, and then on each successive call, increment the offset by the length of the previously-returned chunk.

If @offset is greater than or equal to the total length of @self, then the return value depends on whether or not complete() has been called or not; if it has, then chunk() will return a 0-length chunk (indicating the end of @self). If it has not, then chunk() will return None (indicating that @self may still potentially have more data, but that data is not currently available).

offset

an offset

Returns

a #GBytes

pub fn got_chunk(&self, chunk: &Bytes)

Handles the #SoupMessageBody part of receiving a chunk of data from the network.

Normally this means appending @chunk to @self, exactly as with append_bytes(), but if you have set @self’s accumulate flag to false, then that will not happen.

This is a low-level method which you should not normally need to use.

chunk

a #GBytes received from the network

pub fn set_accumulate(&self, accumulate: bool)

Sets or clears the accumulate flag on @self.

(The default value is true.) If set to false, @self’s data field will not be filled in after the body is fully sent/received, and the chunks that make up @self may be discarded when they are no longer needed.

If you set the flag to false on the Message request_body of a client-side message, it will block the accumulation of chunks into @self’s data field, but it will not normally cause the chunks to be discarded after being written like in the server-side Message response_body case, because the request body needs to be kept around in case the request needs to be sent a second time due to redirection or authentication.

accumulate

whether or not to accumulate body chunks in @self

pub fn truncate(&self)

Deletes all of the data in @self.

pub fn wrote_chunk(&self, chunk: &Bytes)

Handles the #SoupMessageBody part of writing a chunk of data to the network.

Normally this is a no-op, but if you have set @self’s accumulate flag to false, then this will cause @chunk to be discarded to free up memory.

This is a low-level method which you should not need to use, and there are further restrictions on its proper use which are not documented here.

chunk

a #GBytes returned from chunk()

Trait Implementations

impl Clone for MessageBody

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MessageBody

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for MessageBody

fn default() -> Self

Returns the “default value” for a type.

impl From<MessageBody> for Value

fn from(s: MessageBody) -> Self

Converts to this type from the input type.

impl HasParamSpec for MessageBody

type ParamSpec = ParamSpecBoxed

type SetValue = MessageBody

Preferred value to be used as setter for the associated ParamSpec.

type BuilderFn = fn(_: &str) -> ParamSpecBoxedBuilder<'_, MessageBody>

fn param_spec_builder() -> Self::BuilderFn

impl Hash for MessageBody

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for MessageBody

fn cmp(&self, other: &MessageBody) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for MessageBody

fn eq(&self, other: &MessageBody) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for MessageBody

fn partial_cmp(&self, other: &MessageBody) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StaticType for MessageBody

fn static_type() -> Type

Returns the type identifier of Self.

impl Eq for MessageBody

impl StructuralPartialEq for MessageBody