Gjsify LogoGjsify Logo

A #SoupMessage request or response body.

Note that while length always reflects the full length of the message body, data is normally %NULL, and will only be filled in after soup_message_body_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).

record

Hierarchy

  • MessageBody

Index

Constructors

  • Creates a new #SoupMessageBody. #SoupMessage uses this internally; you will not normally need to call it yourself.

    Returns Soup.MessageBody

Properties

data: Uint8Array

the data

field
length: number

length of data

field
name: string

Methods

  • append(data: Uint8Array): void
  • Appends length bytes from data to body.

    This function is exactly equivalent to soup_message_body_append() with %SOUP_MEMORY_TAKE as second argument; it exists mainly for convenience and simplifying language bindings.

    Parameters

    • data: Uint8Array

      data to append

    Returns void

  • appendBytes(buffer: any): void
  • Appends the data from buffer to body.

    Parameters

    • buffer: any

      a #GBytes

    Returns void

  • complete(): void
  • Tags body as being complete; Call this when using chunked encoding after you have appended the last chunk.

    Returns void

  • flatten(): any
  • Fills in body's data field with a buffer containing all of the data in body (plus an additional '\0' byte not counted by body's length field).

    Returns any

  • getAccumulate(): boolean
  • Gets the accumulate flag on body; see soup_message_body_set_accumulate() for details.

    Returns boolean

  • getChunk(offset: number): any
  • Gets a #GBytes 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 soup_message_body_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 soup_message_body_complete() has been called or not; if it has, then soup_message_body_get_chunk() will return a 0-length chunk (indicating the end of body). If it has not, then soup_message_body_get_chunk() will return %NULL (indicating that body may still potentially have more data, but that data is not currently available).

    Parameters

    • offset: number

      an offset

    Returns any

  • gotChunk(chunk: any): void
  • Handles the #SoupMessageBody part of receiving a chunk of data from the network. Normally this means appending chunk to body, exactly as with soup_message_body_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.

    Parameters

    • chunk: any

      a #GBytes received from the network

    Returns void

  • setAccumulate(accumulate: boolean): void
  • 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 #SoupMessage 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 #SoupMessage 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.

    Parameters

    • accumulate: boolean

      whether or not to accumulate body chunks in body

    Returns void

  • truncate(): void
  • unref(): void
  • Atomically decrements the reference count of body by one. When the reference count reaches zero, the resources allocated by body are freed

    Returns void

  • wroteChunk(chunk: any): void
  • Handles the #SoupMessageBody 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.

    Parameters

    • chunk: any

      a #GBytes returned from soup_message_body_get_chunk()

    Returns void

  • Creates a new #SoupMessageBody. #SoupMessage uses this internally; you will not normally need to call it yourself.

    Returns Soup.MessageBody

Legend

  • Module
  • Object literal
  • Variable
  • Function
  • Function with type parameter
  • Index signature
  • Type alias
  • Type alias with type parameter
  • Enumeration
  • Enumeration member
  • Property
  • Method
  • Interface
  • Interface with type parameter
  • Constructor
  • Property
  • Method
  • Index signature
  • Class
  • Class with type parameter
  • Constructor
  • Property
  • Method
  • Accessor
  • Index signature
  • Inherited constructor
  • Inherited property
  • Inherited method
  • Inherited accessor
  • Protected property
  • Protected method
  • Protected accessor
  • Private property
  • Private method
  • Private accessor
  • Static property
  • Static method