AlderconeStudio/PIKApp
AlderconeStudio
/
PIKApp
0
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases 1 Wiki Activity
PIKApp/app/core/pikaparasitelist.c

453 lines
13 KiB
C
Raw Blame History

/* parasitelist.c: Copyright 1998 Jay Cox <jaycox@gimp.org>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <string.h>
#include <gio/gio.h>
#include <gegl.h>
#include "libpikabase/pikabase.h"
#include "libpikaconfig/pikaconfig.h"
#include "core-types.h"
#include "pika-memsize.h"
#include "pikaparasitelist.h"
enum
{
ADD,
REMOVE,
LAST_SIGNAL
};
static void pika_parasite_list_finalize (GObject *object);
static gint64 pika_parasite_list_get_memsize (PikaObject *object,
gint64 *gui_size);
static void pika_parasite_list_config_iface_init (gpointer iface,
gpointer iface_data);
static gboolean pika_parasite_list_serialize (PikaConfig *list,
PikaConfigWriter *writer,
gpointer data);
static gboolean pika_parasite_list_deserialize (PikaConfig *list,
GScanner *scanner,
gint nest_level,
gpointer data);
static void parasite_serialize (const gchar *key,
PikaParasite *parasite,
PikaConfigWriter *writer);
static void parasite_copy (const gchar *key,
PikaParasite *parasite,
PikaParasiteList *list);
static gboolean parasite_free (const gchar *key,
PikaParasite *parasite,
gpointer unused);
static void parasite_count_if_persistent (const gchar *key,
PikaParasite *parasite,
gint *count);
G_DEFINE_TYPE_WITH_CODE (PikaParasiteList, pika_parasite_list, PIKA_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE (PIKA_TYPE_CONFIG,
pika_parasite_list_config_iface_init))
#define parent_class pika_parasite_list_parent_class
static guint parasite_list_signals[LAST_SIGNAL] = { 0 };
static const gchar parasite_symbol[] = "parasite";
static void
pika_parasite_list_class_init (PikaParasiteListClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
PikaObjectClass *pika_object_class = PIKA_OBJECT_CLASS (klass);
parasite_list_signals[ADD] =
g_signal_new ("add",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (PikaParasiteListClass, add),
NULL, NULL, NULL,
G_TYPE_NONE, 1,
G_TYPE_POINTER);
parasite_list_signals[REMOVE] =
g_signal_new ("remove",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (PikaParasiteListClass, remove),
NULL, NULL, NULL,
G_TYPE_NONE, 1,
G_TYPE_POINTER);
object_class->finalize = pika_parasite_list_finalize;
pika_object_class->get_memsize = pika_parasite_list_get_memsize;
klass->add = NULL;
klass->remove = NULL;
}
static void
pika_parasite_list_config_iface_init (gpointer iface,
gpointer iface_data)
{
PikaConfigInterface *config_iface = (PikaConfigInterface *) iface;
config_iface->serialize = pika_parasite_list_serialize;
config_iface->deserialize = pika_parasite_list_deserialize;
}
static void
pika_parasite_list_init (PikaParasiteList *list)
{
list->table = NULL;
}
static void
pika_parasite_list_finalize (GObject *object)
{
PikaParasiteList *list = PIKA_PARASITE_LIST (object);
if (list->table)
{
g_hash_table_foreach_remove (list->table, (GHRFunc) parasite_free, NULL);
g_hash_table_destroy (list->table);
list->table = NULL;
}
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static gint64
pika_parasite_list_get_memsize (PikaObject *object,
gint64 *gui_size)
{
PikaParasiteList *list = PIKA_PARASITE_LIST (object);
gint64 memsize = 0;
memsize += pika_g_hash_table_get_memsize_foreach (list->table,
(PikaMemsizeFunc)
pika_parasite_get_memsize,
gui_size);
return memsize + PIKA_OBJECT_CLASS (parent_class)->get_memsize (object,
gui_size);
}
static gboolean
pika_parasite_list_serialize (PikaConfig *list,
PikaConfigWriter *writer,
gpointer data)
{
if (PIKA_PARASITE_LIST (list)->table)
g_hash_table_foreach (PIKA_PARASITE_LIST (list)->table,
(GHFunc) parasite_serialize,
writer);
return TRUE;
}
static gboolean
pika_parasite_list_deserialize (PikaConfig *list,
GScanner *scanner,
gint nest_level,
gpointer data)
{
GTokenType token;
g_scanner_scope_add_symbol (scanner, 0,
parasite_symbol, (gpointer) parasite_symbol);
token = G_TOKEN_LEFT_PAREN;
while (g_scanner_peek_next_token (scanner) == token)
{
token = g_scanner_get_next_token (scanner);
switch (token)
{
case G_TOKEN_LEFT_PAREN:
token = G_TOKEN_SYMBOL;
break;
case G_TOKEN_SYMBOL:
if (scanner->value.v_symbol == parasite_symbol)
{
gchar *parasite_name = NULL;
gint parasite_flags = 0;
guint8 *parasite_data = NULL;
gint parasite_data_size = 0;
PikaParasite *parasite;
token = G_TOKEN_STRING;
if (g_scanner_peek_next_token (scanner) != token)
break;
if (! pika_scanner_parse_string (scanner, &parasite_name))
break;
token = G_TOKEN_INT;
if (g_scanner_peek_next_token (scanner) != token)
goto cleanup;
if (! pika_scanner_parse_int (scanner, &parasite_flags))
goto cleanup;
token = G_TOKEN_INT;
if (g_scanner_peek_next_token (scanner) != token)
{
/* old format -- plain string */
gchar *str;
if (g_scanner_peek_next_token (scanner) != G_TOKEN_STRING)
goto cleanup;
if (! pika_scanner_parse_string (scanner, &str))
goto cleanup;
parasite_data_size = strlen (str);
parasite_data = (guint8 *) str;
}
else
{
/* new format -- properly encoded binary data */
if (! pika_scanner_parse_int (scanner, &parasite_data_size))
goto cleanup;
token = G_TOKEN_STRING;
if (g_scanner_peek_next_token (scanner) != token)
goto cleanup;
if (! pika_scanner_parse_data (scanner, parasite_data_size,
&parasite_data))
goto cleanup;
}
parasite = pika_parasite_new (parasite_name,
parasite_flags,
parasite_data_size,
parasite_data);
pika_parasite_list_add (PIKA_PARASITE_LIST (list),
parasite); /* adds a copy */
pika_parasite_free (parasite);
token = G_TOKEN_RIGHT_PAREN;
g_free (parasite_data);
cleanup:
g_free (parasite_name);
}
break;
case G_TOKEN_RIGHT_PAREN:
token = G_TOKEN_LEFT_PAREN;
break;
default: /* do nothing */
break;
}
}
return pika_config_deserialize_return (scanner, token, nest_level);
}
PikaParasiteList *
pika_parasite_list_new (void)
{
PikaParasiteList *list;
list = g_object_new (PIKA_TYPE_PARASITE_LIST, NULL);
return list;
}
PikaParasiteList *
pika_parasite_list_copy (PikaParasiteList *list)
{
PikaParasiteList *newlist;
g_return_val_if_fail (PIKA_IS_PARASITE_LIST (list), NULL);
newlist = pika_parasite_list_new ();
if (list->table)
g_hash_table_foreach (list->table, (GHFunc) parasite_copy, newlist);
return newlist;
}
void
pika_parasite_list_add (PikaParasiteList *list,
const PikaParasite *parasite)
{
PikaParasite *copy;
g_return_if_fail (PIKA_IS_PARASITE_LIST (list));
g_return_if_fail (parasite != NULL);
g_return_if_fail (parasite->name != NULL);
if (list->table == NULL)
list->table = g_hash_table_new (g_str_hash, g_str_equal);
pika_parasite_list_remove (list, parasite->name);
copy = pika_parasite_copy (parasite);
g_hash_table_insert (list->table, copy->name, copy);
g_signal_emit (list, parasite_list_signals[ADD], 0, copy);
}
void
pika_parasite_list_remove (PikaParasiteList *list,
const gchar *name)
{
g_return_if_fail (PIKA_IS_PARASITE_LIST (list));
if (list->table)
{
PikaParasite *parasite;
parasite = (PikaParasite *) pika_parasite_list_find (list, name);
if (parasite)
{
g_hash_table_remove (list->table, name);
g_signal_emit (list, parasite_list_signals[REMOVE], 0, parasite);
pika_parasite_free (parasite);
}
}
}
gint
pika_parasite_list_length (PikaParasiteList *list)
{
g_return_val_if_fail (PIKA_IS_PARASITE_LIST (list), 0);
if (! list->table)
return 0;
return g_hash_table_size (list->table);
}
gint
pika_parasite_list_persistent_length (PikaParasiteList *list)
{
gint len = 0;
g_return_val_if_fail (PIKA_IS_PARASITE_LIST (list), 0);
if (! list->table)
return 0;
pika_parasite_list_foreach (list,
(GHFunc) parasite_count_if_persistent, &len);
return len;
}
void
pika_parasite_list_foreach (PikaParasiteList *list,
GHFunc function,
gpointer user_data)
{
g_return_if_fail (PIKA_IS_PARASITE_LIST (list));
if (! list->table)
return;
g_hash_table_foreach (list->table, function, user_data);
}
const PikaParasite *
pika_parasite_list_find (PikaParasiteList *list,
const gchar *name)
{
g_return_val_if_fail (PIKA_IS_PARASITE_LIST (list), NULL);
if (list->table)
return (PikaParasite *) g_hash_table_lookup (list->table, name);
return NULL;
}
static void
parasite_serialize (const gchar *key,
PikaParasite *parasite,
PikaConfigWriter *writer)
{
const guint8 *parasite_contents;
guint32 parasite_size;
if (! pika_parasite_is_persistent (parasite))
return;
pika_config_writer_open (writer, parasite_symbol);
parasite_contents = pika_parasite_get_data (parasite, &parasite_size);
pika_config_writer_printf (writer, "\"%s\" %lu %lu",
pika_parasite_get_name (parasite),
pika_parasite_get_flags (parasite),
(long unsigned int) parasite_size);
pika_config_writer_data (writer, parasite_size, parasite_contents);
pika_config_writer_close (writer);
pika_config_writer_linefeed (writer);
}
static void
parasite_copy (const gchar *key,
PikaParasite *parasite,
PikaParasiteList *list)
{
pika_parasite_list_add (list, parasite);
}
static gboolean
parasite_free (const gchar *key,
PikaParasite *parasite,
gpointer unused)
{
pika_parasite_free (parasite);
return TRUE;
}
static void
parasite_count_if_persistent (const gchar *key,
PikaParasite *parasite,
gint *count)
{
if (pika_parasite_is_persistent (parasite))
*count = *count + 1;
}
Reference in New Issue View Git Blame Copy Permalink