glib/gio/fen/fen-node.c

467 lines
11 KiB
C
Raw Normal View History

/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* vim:set expandtab ts=4 shiftwidth=4: */
/*
* Copyright (C) 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*
* This library 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) any later version.
*
* This library 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 this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* Authors: Lin Ma <lin.ma@sun.com>
*/
#include "config.h"
#include <errno.h>
#include <strings.h>
#include <glib.h>
#include "fen-node.h"
#include "fen-dump.h"
#define NODE_STAT(n) (((node_t*)(n))->stat)
struct _dnode {
gchar* filename;
node_op_t* op;
GTimeVal tv;
};
#ifdef GIO_COMPILATION
#define FN_W if (fn_debug_enabled) g_warning
static gboolean fn_debug_enabled = FALSE;
#else
#include "gam_error.h"
#define FN_W(...) GAM_DEBUG(DEBUG_INFO, __VA_ARGS__)
#endif
G_LOCK_EXTERN (fen_lock);
#define PROCESS_DELETING_INTERVAL 900 /* in second */
static node_t* _head = NULL;
static GList *deleting_nodes = NULL;
static guint deleting_nodes_id = 0;
static node_t* node_new (node_t* parent, const gchar* basename);
static void node_delete (node_t* parent);
static gboolean remove_node_internal (node_t* node, node_op_t* op);
static void children_add (node_t *p, node_t *f);
static void children_remove (node_t *p, node_t *f);
static guint children_foreach_remove (node_t *f, GHRFunc func, gpointer user_data);
static void children_foreach (node_t *f, GHFunc func, gpointer user_data);
static gboolean children_remove_cb (gpointer key,
gpointer value,
gpointer user_data);
static struct _dnode*
_dnode_new (const gchar* filename, node_op_t* op)
{
struct _dnode* d;
g_assert (op);
if ((d = g_new (struct _dnode, 1)) != NULL) {
d->filename = g_strdup (filename);
d->op = g_memdup (op, sizeof (node_op_t));
g_assert (d->op);
g_get_current_time (&d->tv);
g_time_val_add (&d->tv, PROCESS_DELETING_INTERVAL);
}
return d;
}
static void
_dnode_free (struct _dnode* d)
{
g_assert (d);
g_free (d->filename);
g_free (d->op);
g_free (d);
}
static gboolean
g_timeval_lt (GTimeVal *val1, GTimeVal *val2)
{
if (val1->tv_sec < val2->tv_sec)
return TRUE;
if (val1->tv_sec > val2->tv_sec)
return FALSE;
/* val1->tv_sec == val2->tv_sec */
if (val1->tv_usec < val2->tv_usec)
return TRUE;
return FALSE;
}
static gboolean
scan_deleting_nodes (gpointer data)
{
struct _dnode* d;
GTimeVal tv_now;
GList* i;
GList* deleted_list = NULL;
gboolean ret = TRUE;
node_t* node;
g_get_current_time (&tv_now);
if (G_TRYLOCK (fen_lock)) {
for (i = deleting_nodes; i; i = i->next) {
d = (struct _dnode*)i->data;
/* Time to free, try only once */
if (g_timeval_lt (&d->tv, &tv_now)) {
if ((node = _find_node (d->filename)) != NULL) {
remove_node_internal (node, d->op);
}
_dnode_free (d);
deleted_list = g_list_prepend (deleted_list, i);
}
}
for (i = deleted_list; i; i = i->next) {
deleting_nodes = g_list_remove_link (deleting_nodes,
(GList *)i->data);
g_list_free_1 ((GList *)i->data);
}
g_list_free (deleted_list);
if (deleting_nodes == NULL) {
deleting_nodes_id = 0;
ret = FALSE;
}
G_UNLOCK (fen_lock);
}
return ret;
}
gpointer
_node_get_data (node_t* node)
{
g_assert (node);
return node->user_data;
}
gpointer
_node_set_data (node_t* node, gpointer user_data)
{
gpointer data = node->user_data;
g_assert (node);
node->user_data = user_data;
return data;
}
void
_travel_nodes (node_t* node, node_op_t* op)
{
GList* children;
GList* i;
if (node) {
if (op && op->hit) {
op->hit (node, op->user_data);
}
}
children = g_hash_table_get_values (node->children);
if (children) {
for (i = children; i; i = i->next) {
_travel_nodes (i->data, op);
}
g_list_free (children);
}
}
static node_t*
find_node_internal (node_t* node, const gchar* filename, node_op_t* op)
{
gchar* str;
gchar* token;
gchar* lasts;
node_t* parent;
node_t* child;
g_assert (filename && filename[0] == '/');
g_assert (node);
parent = node;
str = g_strdup (filename + strlen (NODE_NAME(parent)));
if ((token = strtok_r (str, G_DIR_SEPARATOR_S, &lasts)) != NULL) {
do {
FN_W ("%s %s + %s\n", __func__, NODE_NAME(parent), token);
child = _children_find (parent, token);
if (child) {
parent = child;
} else {
if (op && op->add_missing) {
child = op->add_missing (parent, op->user_data);
goto L_hit;
}
break;
}
} while ((token = strtok_r (NULL, G_DIR_SEPARATOR_S, &lasts)) != NULL);
} else {
/* It's the head */
g_assert (parent == _head);
child = _head;
}
if (token == NULL && child) {
L_hit:
if (op && op->hit) {
op->hit (child, op->user_data);
}
}
g_free (str);
return child;
}
node_t*
_find_node (const gchar *filename)
{
return find_node_internal (_head, filename, NULL);
}
node_t*
_find_node_full (const gchar* filename, node_op_t* op)
{
return find_node_internal (_head, filename, op);
}
node_t*
_add_node (node_t* parent, const gchar* filename)
{
gchar* str;
gchar* token;
gchar* lasts;
node_t* child = NULL;
g_assert (_head);
g_assert (filename && filename[0] == '/');
if (parent == NULL) {
parent = _head;
}
str = g_strdup (filename + strlen (NODE_NAME(parent)));
if ((token = strtok_r (str, G_DIR_SEPARATOR_S, &lasts)) != NULL) {
do {
FN_W ("%s %s + %s\n", __func__, NODE_NAME(parent), token);
child = node_new (parent, token);
if (child) {
children_add (parent, child);
parent = child;
} else {
break;
}
} while ((token = strtok_r (NULL, G_DIR_SEPARATOR_S, &lasts)) != NULL);
}
g_free (str);
if (token == NULL) {
return child;
} else {
return NULL;
}
}
/*
* delete recursively
*/
static gboolean
remove_children (node_t* node, node_op_t* op)
{
FN_W ("%s 0x%p %s\n", __func__, node, NODE_NAME(node));
if (_children_num (node) > 0) {
children_foreach_remove (node, children_remove_cb,
(gpointer)op);
}
if (_children_num (node) == 0) {
return TRUE;
}
return FALSE;
}
static gboolean
remove_node_internal (node_t* node, node_op_t* op)
{
node_t* parent = NULL;
/*
* If the parent is passive and doesn't have children, delete it.
* NOTE node_delete_deep is a depth first delete recursively.
* Top node is deleted in node_cancel_sub
*/
g_assert (node);
g_assert (op && op->pre_del);
if (node != _head) {
if (remove_children (node, op)) {
if (node->user_data) {
if (!op->pre_del (node, op->user_data)) {
return FALSE;
}
}
parent = node->parent;
children_remove (parent, node);
node_delete (node);
if (_children_num (parent) == 0) {
remove_node_internal (parent, op);
}
return TRUE;
}
return FALSE;
}
return TRUE;
}
void
_pending_remove_node (node_t* node, node_op_t* op)
{
struct _dnode* d;
GList* l;
for (l = deleting_nodes; l; l=l->next) {
d = (struct _dnode*) l->data;
if (g_ascii_strcasecmp (d->filename, NODE_NAME(node)) == 0) {
return;
}
}
d = _dnode_new (NODE_NAME(node), op);
g_assert (d);
deleting_nodes = g_list_prepend (deleting_nodes, d);
if (deleting_nodes_id == 0) {
deleting_nodes_id = g_timeout_add_seconds (PROCESS_DELETING_INTERVAL,
scan_deleting_nodes,
NULL);
g_assert (deleting_nodes_id > 0);
}
}
void
_remove_node (node_t* node, node_op_t* op)
{
remove_node_internal (node, op);
}
static node_t*
node_new (node_t* parent, const gchar* basename)
{
node_t *f = NULL;
g_assert (basename && basename[0]);
if ((f = g_new0 (node_t, 1)) != NULL) {
if (parent) {
f->basename = g_strdup (basename);
f->filename = g_build_filename (G_DIR_SEPARATOR_S,
NODE_NAME(parent), basename, NULL);
} else {
f->basename = g_strdup (basename);
f->filename = g_strdup (basename);
}
f->children = g_hash_table_new_full (g_str_hash, g_str_equal,
NULL, (GDestroyNotify)node_delete);
FN_W ("[ %s ] 0x%p %s\n", __func__, f, NODE_NAME(f));
}
return f;
}
static void
node_delete (node_t *f)
{
FN_W ("[ %s ] 0x%p %s\n", __func__, f, NODE_NAME(f));
g_assert (g_hash_table_size (f->children) == 0);
g_assert (f->user_data == NULL);
g_hash_table_unref (f->children);
g_free (f->basename);
g_free (f->filename);
g_free (f);
}
static void
children_add (node_t *p, node_t *f)
{
FN_W ("%s [p] %8s [c] %8s\n", __func__, p->basename, f->basename);
g_hash_table_insert (p->children, f->basename, f);
f->parent = p;
}
static void
children_remove (node_t *p, node_t *f)
{
FN_W ("%s [p] %8s [c] %8s\n", __func__, p->basename, f->basename);
g_hash_table_steal (p->children, f->basename);
f->parent = NULL;
}
guint
_children_num (node_t *f)
{
return g_hash_table_size (f->children);
}
node_t *
_children_find (node_t *f, const gchar *basename)
{
return (node_t *) g_hash_table_lookup (f->children, (gpointer)basename);
}
/*
* depth first delete recursively
*/
static gboolean
children_remove_cb (gpointer key,
gpointer value,
gpointer user_data)
{
node_t* f = (node_t*)value;
node_op_t* op = (node_op_t*) user_data;
g_assert (f->parent);
FN_W ("%s [p] %8s [c] %8s\n", __func__, f->parent->basename, f->basename);
if (remove_children (f, op)) {
if (f->user_data != NULL) {
return op->pre_del (f, op->user_data);
}
return TRUE;
}
return FALSE;
}
static guint
children_foreach_remove (node_t *f, GHRFunc func, gpointer user_data)
{
g_assert (f);
return g_hash_table_foreach_remove (f->children, func, user_data);
}
static void
children_foreach (node_t *f, GHFunc func, gpointer user_data)
{
g_assert (f);
g_hash_table_foreach (f->children, func, user_data);
}
gboolean
_node_class_init ()
{
FN_W ("%s\n", __func__);
if (_head == NULL) {
_head = node_new (NULL, G_DIR_SEPARATOR_S);
}
return _head != NULL;
}