| Top |  |  |  |  | 
CamelDataWrapper *
camel_data_wrapper_new (void);
Create a new CamelDataWrapper object.
GByteArray *
camel_data_wrapper_get_byte_array (CamelDataWrapper *data_wrapper);
Returns the GByteArray being used to hold the contents of data_wrapper
.
Note, it's up to the caller to use this in a thread-safe manner.
Since: 3.2
CamelTransferEncoding
camel_data_wrapper_get_encoding (CamelDataWrapper *data_wrapper);
Since: 3.24
void camel_data_wrapper_set_encoding (CamelDataWrapper *data_wrapper,CamelTransferEncoding encoding);
Sets encoding (CamelTransferEncoding) for the data_wrapper
.
It doesn't re-encode the content, if the encoding changes.
Since: 3.24
void camel_data_wrapper_set_mime_type (CamelDataWrapper *data_wrapper,const gchar *mime_type);
This sets the data wrapper's MIME type.
It might fail, but you won't know. It will allow you to set Content-Type parameters on the data wrapper, which are meaningless. You should not be allowed to change the MIME type of a data wrapper that contains data, or at least, if you do, it should invalidate the data.
gchar *
camel_data_wrapper_get_mime_type (CamelDataWrapper *data_wrapper);
CamelContentType *
camel_data_wrapper_get_mime_type_field
                               (CamelDataWrapper *data_wrapper);
void camel_data_wrapper_set_mime_type_field (CamelDataWrapper *data_wrapper,CamelContentType *mime_type);
This sets the data wrapper's MIME type. It adds its own reference
to mime_type
, if not NULL.
It suffers from the same flaws as camel_data_wrapper_set_mime_type().
void camel_data_wrapper_take_mime_type_field (CamelDataWrapper *data_wrapper,CamelContentType *mime_type);
Sets mime-type filed to be mime_type
 and consumes it, aka unlike
camel_data_wrapper_set_mime_type_field(), this doesn't add its own
reference to mime_type
.
It suffers from the same flaws as camel_data_wrapper_set_mime_type().
Since: 3.24
gboolean
camel_data_wrapper_is_offline (CamelDataWrapper *data_wrapper);
void camel_data_wrapper_set_offline (CamelDataWrapper *data_wrapper,gboolean offline);
Sets whether the data_wrapper
 is "offline". It applies only to this
concrete instance. See camel_data_wrapper_is_offline().
Since: 3.24
gssize camel_data_wrapper_write_to_stream_sync (CamelDataWrapper *data_wrapper,CamelStream *stream,GCancellable *cancellable,GError **error);
Writes the content of data_wrapper
 to stream
 in a machine-independent
format appropriate for the data.  It should be possible to construct an
equivalent data wrapper object later by passing this stream to
camel_data_wrapper_construct_from_stream_sync().
    This function may block even if the given output stream does not.
    For example, the content may have to be fetched across a network
    before it can be written to stream.
  
| data_wrapper | a CamelDataWrapper | |
| stream | a CamelStream for output | |
| cancellable | optional GCancellable object, or  | |
| error | 
Since: 3.0
void camel_data_wrapper_write_to_stream (CamelDataWrapper *data_wrapper,CamelStream *stream,gint io_priority,GCancellable *cancellable,GAsyncReadyCallback callback,gpointer user_data);
Asynchronously writes the content of data_wrapper
 to stream
 in a
machine-independent format appropriate for the data.  It should be
possible to construct an equivalent data wrapper object later by
passing this stream to camel_data_wrapper_construct_from_stream().
When the operation is finished, callback
 will be called.  You can then
call camel_data_wrapper_write_to_stream_finish() to get the result of
the operation.
| data_wrapper | a CamelDataWrapper | |
| stream | a CamelStream for writed data to be written to | |
| io_priority | the I/O priority of the request | |
| cancellable | optional GCancellable object, or  | |
| callback | a GAsyncReadyCallback to call when the request is satisfied | |
| user_data | data to pass to the callback function | 
Since: 3.0
gssize camel_data_wrapper_write_to_stream_finish (CamelDataWrapper *data_wrapper,GAsyncResult *result,GError **error);
Finishes the operation started with camel_data_wrapper_write_to_stream().
Since: 3.0
gssize camel_data_wrapper_decode_to_stream_sync (CamelDataWrapper *data_wrapper,CamelStream *stream,GCancellable *cancellable,GError **error);
Writes the decoded data content to stream
.
    This function may block even if the given output stream does not.
    For example, the content may have to be fetched across a network
    before it can be written to stream.
  
| data_wrapper | a CamelDataWrapper | |
| stream | a CamelStream for decoded data to be written to | |
| cancellable | optional GCancellable object, or  | |
| error | 
Since: 3.0
void camel_data_wrapper_decode_to_stream (CamelDataWrapper *data_wrapper,CamelStream *stream,gint io_priority,GCancellable *cancellable,GAsyncReadyCallback callback,gpointer user_data);
Asynchronously writes the decoded data content to stream
.
When the operation is finished, callback
 will be called.  You can then
call camel_data_wrapper_decode_to_stream_finish() to get the result of
the operation.
| data_wrapper | a CamelDataWrapper | |
| stream | a CamelStream for decoded data to be written to | |
| io_priority | the I/O priority of the request | |
| cancellable | optional GCancellable object, or  | |
| callback | a GAsyncReadyCallback to call when the request is satisfied | |
| user_data | data to pass to the callback function | 
Since: 3.0
gssize camel_data_wrapper_decode_to_stream_finish (CamelDataWrapper *data_wrapper,GAsyncResult *result,GError **error);
Finishes the operation started with camel_data_wrapper_decode_to_stream().
Since: 3.0
gboolean camel_data_wrapper_construct_from_stream_sync (CamelDataWrapper *data_wrapper,CamelStream *stream,GCancellable *cancellable,GError **error);
Constructs the content of data_wrapper
 from the given stream
.
| data_wrapper | a CamelDataWrapper | |
| stream | an input CamelStream | |
| cancellable | optional GCancellable object, or  | |
| error | 
Since: 3.0
void camel_data_wrapper_construct_from_stream (CamelDataWrapper *data_wrapper,CamelStream *stream,gint io_priority,GCancellable *cancellable,GAsyncReadyCallback callback,gpointer user_data);
Asynchronously constructs the content of data_wrapper
 from the given
stream
.
When the operation is finished, callback
 will be called.  You can then
call camel_data_wrapper_construct_from_stream_finish() to get the result
of the operation.
| data_wrapper | a CamelDataWrapper | |
| stream | an input CamelStream | |
| io_priority | the I/O priority of the request | |
| cancellable | optional GCancellable object, or  | |
| callback | a GAsyncReadyCallback to call when the request is satisfied | |
| user_data | data to pass to the callback function | 
Since: 3.0
gboolean camel_data_wrapper_construct_from_stream_finish (CamelDataWrapper *data_wrapper,GAsyncResult *result,GError **error);
Finishes the operation started with
camel_data_wrapper_construct_from_stream().
Since: 3.0
gssize camel_data_wrapper_write_to_output_stream_sync (CamelDataWrapper *data_wrapper,GOutputStream *output_stream,GCancellable *cancellable,GError **error);
Writes the content of data_wrapper
 to output_stream
 in a
machine-independent format appropriate for the data.
    This function may block even if the given output stream does not.
    For example, the content may have to be fetched across a network
    before it can be written to output_stream.
  
| data_wrapper | a CamelDataWrapper | |
| output_stream | ||
| cancellable | optional GCancellable object, or  | |
| error | 
Since: 3.12
void camel_data_wrapper_write_to_output_stream (CamelDataWrapper *data_wrapper,GOutputStream *output_stream,gint io_priority,GCancellable *cancellable,GAsyncReadyCallback callback,gpointer user_data);
Asynchronously writes the content of data_wrapper
 to output_stream
 in
a machine-independent format appropriate for the data.
When the operation is finished, callback
 will be called.  You can then
call camel_data_wrapper_write_to_output_stream_finish() to get the result
of the operation.
| data_wrapper | a CamelDataWrapper | |
| output_stream | ||
| io_priority | the I/O priority of the request | |
| cancellable | optional GCancellable object, or  | |
| callback | a GAsyncReadyCallback to call when the request is satisfied | |
| user_data | data to pass to the callback function | 
Since: 3.12
gssize camel_data_wrapper_write_to_output_stream_finish (CamelDataWrapper *data_wrapper,GAsyncResult *result,GError **error);
Finishes the operation started with
camel_data_wrapper_write_to_output_stream().
Since: 3.12
gssize camel_data_wrapper_decode_to_output_stream_sync (CamelDataWrapper *data_wrapper,GOutputStream *output_stream,GCancellable *cancellable,GError **error);
Writes the decoded data content to output_stream
.
    This function may block even if the given output stream does not.
    For example, the content may have to be fetched across a network
    before it can be written to output_stream.
  
| data_wrapper | a CamelDataWrapper | |
| output_stream | ||
| cancellable | optional GCancellable object, or  | |
| error | 
Since: 3.12
void camel_data_wrapper_decode_to_output_stream (CamelDataWrapper *data_wrapper,GOutputStream *output_stream,gint io_priority,GCancellable *cancellable,GAsyncReadyCallback callback,gpointer user_data);
Asynchronously writes the decoded data content to output_stream
.
When the operation is finished, callback
 will be called.  You can then
call camel_data_wrapper_decode_to_output_stream_finish() to get the result
of the operation.
| data_wrapper | a CamelDataWrapper | |
| output_stream | ||
| io_priority | the I/O priority of the request | |
| cancellable | optional GCancellable object, or  | |
| callback | a GAsyncReadyCallback to call when the request is satisfied | |
| user_data | data to pass to the callback function | 
Since: 3.12
gssize camel_data_wrapper_decode_to_output_stream_finish (CamelDataWrapper *data_wrapper,GAsyncResult *result,GError **error);
Finishes the operation started with
camel_data_wrapper_decode_to_output_stream().
Since: 3.12
gboolean camel_data_wrapper_construct_from_input_stream_sync (CamelDataWrapper *data_wrapper,GInputStream *input_stream,GCancellable *cancellable,GError **error);
Constructs the content of data_wrapper
 from input_stream
.
| data_wrapper | a CamelDataWrapper | |
| input_stream | ||
| cancellable | optional GCancellable object, or  | |
| error | 
Since: 3.12
void camel_data_wrapper_construct_from_input_stream (CamelDataWrapper *data_wrapper,GInputStream *input_stream,gint io_priority,GCancellable *cancellable,GAsyncReadyCallback callback,gpointer user_data);
Asynchronously constructs the content of data_wrapper
 from input_stream
.
When the operation is finished, callback
 will be called.  You can then
call camel_data_wrapper_construct_from_input_stream_finish() to get the
result of the operation.
| data_wrapper | a CamelDataWrapper | |
| input_stream | ||
| io_priority | the I/O priority of the request | |
| cancellable | optional GCancellable object, or  | |
| callback | a GAsyncReadyCallback to call when the request is satisfied | |
| user_data | data to pass to the callback function | 
Since: 3.12
gboolean camel_data_wrapper_construct_from_input_stream_finish (CamelDataWrapper *data_wrapper,GAsyncResult *result,GError **error);
Finishes the operation started with
camel_data_wrapper_construct_from_input_stream().
Since: 3.12
gsize camel_data_wrapper_calculate_size_sync (CamelDataWrapper *data_wrapper,GCancellable *cancellable,GError **error);
Calculates size of the data_wrapper
 by saving it to a null-stream
and returns how many bytes had been written. It's using
camel_data_wrapper_write_to_stream_sync() internally.
Since: 3.24
gsize camel_data_wrapper_calculate_decoded_size_sync (CamelDataWrapper *data_wrapper,GCancellable *cancellable,GError **error);
Calculates decoded size of the data_wrapper
 by saving it to a null-stream
and returns how many bytes had been written. It's using
camel_data_wrapper_decode_to_stream_sync() internally.
Since: 3.24