path: root/e-util/e-data-capture.c

/*
 * e-data-capture.c
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with the program; if not, see <http://www.gnu.org/licenses/>
 *
 */

/**
 * SECTION: e-data-capture
 * @include: e-util/e-util.h
 * @short_description: Capture data from streams
 *
 * #EDataCapture is a #GConverter that captures data until the end of
 * the input data is seen, then emits a #EDataCapture:finished signal
 * with the captured data in a #GBytes instance.
 *
 * When used with #GConverterInputStream or #GConverterOutputStream,
 * an #EDataCapture can discreetly capture the stream content for the
 * purpose of caching.
 **/

#include "e-data-capture.h"

#include <string.h>

#define E_DATA_CAPTURE_GET_PRIVATE(obj) \
    (G_TYPE_INSTANCE_GET_PRIVATE \
    ((obj), E_TYPE_DATA_CAPTURE, EDataCapturePrivate))

typedef struct _SignalClosure SignalClosure;

struct _EDataCapturePrivate {
    GMainContext *main_context;
    GByteArray *byte_array;
    GMutex byte_array_lock;
};

struct _SignalClosure {
    GWeakRef data_capture;
    GBytes *data;
};

enum {
    PROP_0,
    PROP_MAIN_CONTEXT
};

enum {
    FINISHED,
    LAST_SIGNAL
};

static guint signals[LAST_SIGNAL];

/* Forward Declarations */
static void e_data_capture_converter_init   (GConverterIface *interface);

G_DEFINE_TYPE_WITH_CODE (
    EDataCapture,
    e_data_capture,
    G_TYPE_OBJECT,
    G_IMPLEMENT_INTERFACE (
        G_TYPE_CONVERTER,
        e_data_capture_converter_init))

static void
signal_closure_free (SignalClosure *signal_closure)
{
    g_weak_ref_set (&signal_closure->data_capture, NULL);
    g_bytes_unref (signal_closure->data);

    g_slice_free (SignalClosure, signal_closure);
}

static gboolean
data_capture_emit_finished_idle_cb (gpointer user_data)
{
    SignalClosure *signal_closure = user_data;
    EDataCapture *data_capture;

    data_capture = g_weak_ref_get (&signal_closure->data_capture);

    if (data_capture != NULL) {
        g_signal_emit (
            data_capture,
            signals[FINISHED], 0,
            signal_closure->data);
        g_object_unref (data_capture);
    }

    return FALSE;
}

static void
data_capture_set_main_context (EDataCapture *data_capture,
                               GMainContext *main_context)
{
    g_return_if_fail (data_capture->priv->main_context == NULL);

    if (main_context != NULL)
        g_main_context_ref (main_context);
    else
        main_context = g_main_context_ref_thread_default ();

    data_capture->priv->main_context = main_context;
}

static void
data_capture_set_property (GObject *object,
                           guint property_id,
                           const GValue *value,
                           GParamSpec *pspec)
{
    switch (property_id) {
        case PROP_MAIN_CONTEXT:
            data_capture_set_main_context (
                E_DATA_CAPTURE (object),
                g_value_get_boxed (value));
            return;
    }

    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
data_capture_get_property (GObject *object,
                           guint property_id,
                           GValue *value,
                           GParamSpec *pspec)
{
    switch (property_id) {
        case PROP_MAIN_CONTEXT:
            g_value_take_boxed (
                value,
                e_data_capture_ref_main_context (
                E_DATA_CAPTURE (object)));
            return;
    }

    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
data_capture_finalize (GObject *object)
{
    EDataCapturePrivate *priv;

    priv = E_DATA_CAPTURE_GET_PRIVATE (object);

    g_main_context_unref (priv->main_context);

    g_byte_array_free (priv->byte_array, TRUE);
    g_mutex_clear (&priv->byte_array_lock);

    /* Chain up to parent's finalize() method. */
    G_OBJECT_CLASS (e_data_capture_parent_class)->finalize (object);
}

static GConverterResult
data_capture_convert (GConverter *converter,
                      gconstpointer inbuf,
                      gsize inbuf_size,
                      gpointer outbuf,
                      gsize outbuf_size,
                      GConverterFlags flags,
                      gsize *bytes_read,
                      gsize *bytes_written,
                      GError **error)
{
    EDataCapture *data_capture;
    GConverterResult result;

    data_capture = E_DATA_CAPTURE (converter);

    /* Output buffer needs to be at least as large as the input buffer.
     * The error message should never make it to the user interface so
     * no need to translate. */
    if (outbuf_size < inbuf_size) {
        g_set_error_literal (
            error, G_IO_ERROR,
            G_IO_ERROR_NO_SPACE,
            "EDataCapture needs more space");
        return G_CONVERTER_ERROR;
    }

    memcpy (outbuf, inbuf, inbuf_size);
    *bytes_read = *bytes_written = inbuf_size;

    g_mutex_lock (&data_capture->priv->byte_array_lock);

    g_byte_array_append (
        data_capture->priv->byte_array, inbuf, inbuf_size);

    if ((flags & G_CONVERTER_INPUT_AT_END) != 0) {
        GSource *idle_source;
        GMainContext *main_context;
        SignalClosure *signal_closure;

        signal_closure = g_slice_new0 (SignalClosure);
        g_weak_ref_set (&signal_closure->data_capture, data_capture);
        signal_closure->data = g_bytes_new (
            data_capture->priv->byte_array->data,
            data_capture->priv->byte_array->len);

        main_context = e_data_capture_ref_main_context (data_capture);

        idle_source = g_idle_source_new ();
        g_source_set_callback (
            idle_source,
            data_capture_emit_finished_idle_cb,
            signal_closure,
            (GDestroyNotify) signal_closure_free);
        g_source_set_priority (idle_source, G_PRIORITY_HIGH_IDLE);
        g_source_attach (idle_source, main_context);
        g_source_unref (idle_source);

        g_main_context_unref (main_context);
    }

    g_mutex_unlock (&data_capture->priv->byte_array_lock);

    if ((flags & G_CONVERTER_INPUT_AT_END) != 0)
        result = G_CONVERTER_FINISHED;
    else if ((flags & G_CONVERTER_FLUSH) != 0)
        result = G_CONVERTER_FLUSHED;
    else
        result = G_CONVERTER_CONVERTED;

    return result;
}

static void
data_capture_reset (GConverter *converter)
{
    EDataCapture *data_capture;

    data_capture = E_DATA_CAPTURE (converter);

    g_mutex_lock (&data_capture->priv->byte_array_lock);

    g_byte_array_set_size (data_capture->priv->byte_array, 0);

    g_mutex_unlock (&data_capture->priv->byte_array_lock);
}

static void
e_data_capture_class_init (EDataCaptureClass *class)
{
    GObjectClass *object_class;

    g_type_class_add_private (class, sizeof (EDataCapturePrivate));

    object_class = G_OBJECT_CLASS (class);
    object_class->set_property = data_capture_set_property;
    object_class->get_property = data_capture_get_property;
    object_class->finalize = data_capture_finalize;

    /**
     * EDataCapture:main-context:
     *
     * The #GMainContext from which to emit the #EDataCapture::finished
     * signal.
     **/
    g_object_class_install_property (
        object_class,
        PROP_MAIN_CONTEXT,
        g_param_spec_boxed (
            "main-context",
            "Main Context",
            "The main loop context from "
            "which to emit the 'finished' signal",
            G_TYPE_MAIN_CONTEXT,
            G_PARAM_READWRITE |
            G_PARAM_CONSTRUCT_ONLY |
            G_PARAM_STATIC_STRINGS));

    /**
     * EDataCapture::finished:
     * @data_capture: the #EDataCapture that received the signal
     * @data: the captured data
     *
     * The ::finished signal is emitted when there is no more input
     * data to be captured.
     **/
    signals[FINISHED] = g_signal_new (
        "finished",
        G_TYPE_FROM_CLASS (class),
        G_SIGNAL_RUN_FIRST,
        G_STRUCT_OFFSET (EDataCaptureClass, finished),
        NULL, NULL, NULL,
        G_TYPE_NONE, 1,
        G_TYPE_BYTES);
}

static void
e_data_capture_converter_init (GConverterIface *interface)
{
    interface->convert = data_capture_convert;
    interface->reset = data_capture_reset;
}

static void
e_data_capture_init (EDataCapture *data_capture)
{
    data_capture->priv = E_DATA_CAPTURE_GET_PRIVATE (data_capture);

    data_capture->priv->byte_array = g_byte_array_new ();
    g_mutex_init (&data_capture->priv->byte_array_lock);
}

/**
 * e_data_capture_new:
 * @main_context: a #GMainContext, or %NULL
 *
 * Creates a new #EDataCapture.  If @main_context is %NULL, then the
 * #EDataCapture:finished signal will be emitted from the thread-default
 * #GMainContext for this thread.
 *
 * Returns: an #EDataCapture
 **/
EDataCapture *
e_data_capture_new (GMainContext *main_context)
{
    return g_object_new (
        E_TYPE_DATA_CAPTURE,
        "main-context", main_context, NULL);
}

/**
 * e_data_capture_ref_main_context:
 * @data_capture: an #EDataCapture
 *
 * Returns the #GMainContext from which the #EDataCapture:finished signal
 * is emitted.
 *
 * The returned #GMainContext is referenced for thread-safety and must be
 * unreferenced with g_main_context_unref() when finished with it.
 *
 * Returns: a #GMainContext
 **/
GMainContext *
e_data_capture_ref_main_context (EDataCapture *data_capture)
{
    g_return_val_if_fail (E_IS_DATA_CAPTURE (data_capture), NULL);

    return g_main_context_ref (data_capture->priv->main_context);
}