Memory-managed wrapper type.

Construct a MessageBody struct initialized to zero.

Appends length bytes from data to body.

This function is exactly equivalent to [methodmessageBody.append] with MemoryUseTake as second argument; it exists mainly for convenience and simplifying language bindings.

Appends the data from buffer to body.

Tags body as being complete.

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

Fills in body's data field with a buffer containing all of the data in body.

Adds an additional \0 byte not counted by body's length field.

Gets the accumulate flag on body.

See [methodmessageBody.set_accumulate. for details.

Gets a [structgLib.Bytes] containing data from body starting at offset.

The size of the returned chunk is unspecified. You can iterate through the entire body by first calling [methodmessageBody.get_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 body, then the return value depends on whether or not [methodmessageBody.complete] has been called or not; if it has, then [methodmessageBody.get_chunk] will return a 0-length chunk (indicating the end of body). If it has not, then [methodmessageBody.get_chunk] will return Nothing (indicating that body may still potentially have more data, but that data is not currently available).

Handles the MessageBody part of receiving a chunk of data from the network.

Normally this means appending chunk to body, exactly as with [methodmessageBody.append_bytes], but if you have set body's accumulate flag to False, then that will not happen.

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

Creates a new MessageBody.

classmessage

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

Atomically increments the reference count of body by one.

Sets or clears the accumulate flag on body.

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

If you set the flag to False on the [classmessage] request_body of a client-side message, it will block the accumulation of chunks into body's data field, but it will not normally cause the chunks to be discarded after being written like in the server-side [classmessage] 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.

Deletes all of the data in body.

Atomically decrements the reference count of body by one.

When the reference count reaches zero, the resources allocated by body are freed

Handles the MessageBody part of writing a chunk of data to the network.

Normally this is a no-op, but if you have set body'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.

Get the value of the “length” field. When overloading is enabled, this is equivalent to

get messageBody #length

Set the value of the “length” field. When overloading is enabled, this is equivalent to

set messageBody [ #length := value ]