We don't want to export a lot of non-namespaced internal symbols.
static void scan_known_children (node_t* f);
node_t*
-add_missing_cb (node_t* parent, gpointer user_data)
+_add_missing_cb (node_t* parent, gpointer user_data)
{
g_assert (parent);
FD_W ("%s p:0x%p %s\n", __func__, parent, (gchar*)user_data);
- return add_node (parent, (gchar*)user_data);
+ return _add_node (parent, (gchar*)user_data);
}
gboolean
-pre_del_cb (node_t* node, gpointer user_data)
+_pre_del_cb (node_t* node, gpointer user_data)
{
fdata* data;
g_assert (node);
- data = node_get_data (node);
+ data = _node_get_data (node);
FD_W ("%s node:0x%p %s\n", __func__, node, NODE_NAME(node));
if (data != NULL) {
if (!FN_IS_PASSIVE(data)) {
return FALSE;
}
-/**
+/*
* If all active children nodes are ported, then cancel monitor the parent node
*
* Unsafe, need lock.
fdata* pdata;
FD_W ("%s %s [0x%p]\n", __func__, NODE_NAME(f), f);
- pdata = node_get_data (f);
+ pdata = _node_get_data (f);
/*
* Currect fdata must is directly monitored. Be sure it is 1 level monitor.
*/
* If the node is existed, and isn't ported, then emit created
* event. Ignore others.
*/
- childf = children_find (f, basename);
+ childf = _children_find (f, basename);
if (childf &&
- (data = node_get_data (childf)) != NULL &&
+ (data = _node_get_data (childf)) != NULL &&
!FN_IS_PASSIVE (data)) {
if (!is_monitoring (data) &&
- port_add (&data->fobj, &data->len, data)) {
- fdata_emit_events (data, FN_EVENT_CREATED);
+ _port_add (&data->fobj, &data->len, data)) {
+ _fdata_emit_events (data, FN_EVENT_CREATED);
}
}
}
fdata* pdata;
FD_W ("%s %s [0x%p]\n", __func__, NODE_NAME(f), f);
- pdata = node_get_data (f);
+ pdata = _node_get_data (f);
/*
* Currect fdata must is directly monitored. Be sure it is 1 level monitor.
*/
fdata* data;
GList *idx;
- childf = children_find (f, basename);
+ childf = _children_find (f, basename);
if (childf == NULL) {
gchar *filename;
filename = g_build_filename (NODE_NAME(f), basename, NULL);
- childf = add_node (f, filename);
+ childf = _add_node (f, filename);
g_assert (childf);
- data = fdata_new (childf, FALSE);
+ data = _fdata_new (childf, FALSE);
g_free (filename);
}
- if ((data = node_get_data (childf)) == NULL) {
- data = fdata_new (childf, FALSE);
+ if ((data = _node_get_data (childf)) == NULL) {
+ data = _fdata_new (childf, FALSE);
}
/* Be sure data isn't ported and add to port successfully */
/* Don't need delete it, it will be deleted by the parent */
if (is_monitoring (data)) {
/* Ignored */
- } else if (/* !is_ported (data) && */
- port_add (&data->fobj, &data->len, data)) {
- fdata_emit_events (data, FN_EVENT_CREATED);
+ } else if (/* !_is_ported (data) && */
+ _port_add (&data->fobj, &data->len, data)) {
+ _fdata_emit_events (data, FN_EVENT_CREATED);
}
}
g_dir_close (dir);
gboolean
is_monitoring (fdata* data)
{
- return is_ported (data) || data->change_update_id > 0;
+ return _is_ported (data) || data->change_update_id > 0;
}
fdata*
-get_parent_data (fdata* data)
+_get_parent_data (fdata* data)
{
if (FN_NODE(data) && !IS_TOPNODE(FN_NODE(data))) {
- return node_get_data (FN_NODE(data)->parent);
+ return _node_get_data (FN_NODE(data)->parent);
}
return NULL;
}
node_t*
-get_parent_node (fdata* data)
+_get_parent_node (fdata* data)
{
if (FN_NODE(data)) {
return (FN_NODE(data)->parent);
}
fdata *
-fdata_new (node_t* node, gboolean is_mondir)
+_fdata_new (node_t* node, gboolean is_mondir)
{
fdata *f = NULL;
f->is_dir = is_mondir;
f->eventq = g_queue_new ();
FD_W ("[ %s ] 0x%p %s\n", __func__, f, FN_NAME(f));
- node_set_data (node, f);
+ _node_set_data (node, f);
}
return f;
}
FD_W ("[ TRY %s ] 0x%p id[%4d:%4d] %s\n", __func__, f, f->eventq_id, f->change_update_id, FN_NAME(f));
g_assert (FN_IS_PASSIVE(f));
- port_remove (f);
- /* missing_remove (f); */
+ _port_remove (f);
+ /* _missing_remove (f); */
if (f->node != NULL) {
- node_set_data (f->node, NULL);
+ _node_set_data (f->node, NULL);
f->node = NULL;
}
FD_W ("[ %s ] 0x%p %s\n", __func__, f, FN_NAME(f));
while ((ev = g_queue_pop_head (f->eventq)) != NULL) {
- fnode_event_delete (ev);
+ _fnode_event_delete (ev);
}
g_queue_free (f->eventq);
}
void
-fdata_reset (fdata* data)
+_fdata_reset (fdata* data)
{
fnode_event_t *ev;
g_assert (data);
while ((ev = g_queue_pop_head (data->eventq)) != NULL) {
- fnode_event_delete (ev);
+ _fnode_event_delete (ev);
}
}
}
void
-fdata_sub_add (fdata *f, gpointer sub)
+_fdata_sub_add (fdata *f, gpointer sub)
{
FD_W ("[%s] [data: 0x%p ] [s: 0x%p ] %s\n", __func__, f, sub, FN_NAME(f));
g_assert (g_list_find_custom (f->subs, sub, (GCompareFunc)fdata_sub_find) == NULL);
}
void
-fdata_sub_remove (fdata *f, gpointer sub)
+_fdata_sub_remove (fdata *f, gpointer sub)
{
GList *l;
FD_W ("[%s] [data: 0x%p ] [s: 0x%p ] %s\n", __func__, f, sub, FN_NAME(f));
f->subs = g_list_delete_link (f->subs, l);
}
-/**
+/*
* Adjust self on failing to Port
*/
void
-fdata_adjust_deleted (fdata* f)
+_fdata_adjust_deleted (fdata* f)
{
node_t* parent;
fdata* pdata;
- node_op_t op = {NULL, NULL, pre_del_cb, NULL};
+ node_op_t op = {NULL, NULL, _pre_del_cb, NULL};
/*
* It's a top node. We move it to missing list.
*/
- parent = get_parent_node (f);
- pdata = get_parent_data (f);
+ parent = _get_parent_node (f);
+ pdata = _get_parent_data (f);
if (!FN_IS_PASSIVE(f) ||
- children_num (FN_NODE(f)) > 0 ||
+ _children_num (FN_NODE(f)) > 0 ||
(pdata && !FN_IS_PASSIVE(pdata))) {
if (parent) {
if (pdata == NULL) {
- pdata = fdata_new (parent, FALSE);
+ pdata = _fdata_new (parent, FALSE);
}
g_assert (pdata);
- if (!port_add (&pdata->fobj, &pdata->len, pdata)) {
- fdata_adjust_deleted (pdata);
+ if (!_port_add (&pdata->fobj, &pdata->len, pdata)) {
+ _fdata_adjust_deleted (pdata);
}
} else {
/* f is root */
g_assert (IS_TOPNODE(FN_NODE(f)));
- missing_add (f);
+ _missing_add (f);
}
} else {
#ifdef GIO_COMPILATION
- pending_remove_node (FN_NODE(f), &op);
+ _pending_remove_node (FN_NODE(f), &op);
#else
- remove_node (FN_NODE(f), &op);
+ _remove_node (FN_NODE(f), &op);
#endif
}
}
fdata* pdata;
G_LOCK (fen_lock);
- parent = get_parent_node (f);
- pdata = get_parent_data (f);
+ parent = _get_parent_node (f);
+ pdata = _get_parent_data (f);
if (!FN_IS_LIVING(f) ||
- (children_num (FN_NODE(f)) == 0 &&
+ (_children_num (FN_NODE(f)) == 0 &&
FN_IS_PASSIVE(f) &&
pdata && FN_IS_PASSIVE(pdata))) {
f->change_update_id = 0;
if (f->len != buf.st_size) {
/* FD_W ("LEN [%lld:%lld] %s\n", f->len, buf.st_size, FN_NAME(f)); */
f->len = buf.st_size;
- ev = fnode_event_new (FILE_MODIFIED, TRUE, f);
+ ev = _fnode_event_new (FILE_MODIFIED, TRUE, f);
if (ev != NULL) {
ev->is_pending = TRUE;
- fdata_add_event (f, ev);
+ _fdata_add_event (f, ev);
}
/* Fdata is still changing, so scalable scan */
f->change_update_id = g_timeout_add (get_scalable_scan_time (f),
scan_children (FN_NODE(f));
} else {
scan_known_children (FN_NODE(f));
- if ((children_num (FN_NODE(f)) == 0 &&
+ if ((_children_num (FN_NODE(f)) == 0 &&
FN_IS_PASSIVE(f) &&
pdata && FN_IS_PASSIVE(pdata))) {
- port_remove (f);
+ _port_remove (f);
goto L_exit;
}
}
}
- if (!port_add_simple (&f->fobj, f)) {
+ if (!_port_add_simple (&f->fobj, f)) {
L_delete:
- ev = fnode_event_new (FILE_DELETE, FALSE, f);
+ ev = _fnode_event_new (FILE_DELETE, FALSE, f);
if (ev != NULL) {
- fdata_add_event (f, ev);
+ _fdata_add_event (f, ev);
}
}
}
}
void
-fdata_emit_events_once (fdata *f, int event, gpointer sub)
+_fdata_emit_events_once (fdata *f, int event, gpointer sub)
{
emit_once_cb (f, _event_converter (event), sub);
}
void
-fdata_emit_events (fdata *f, int event)
+_fdata_emit_events (fdata *f, int event)
{
emit_cb (f, _event_converter (event));
}
static gboolean
process_events (gpointer udata)
{
- node_op_t op = {NULL, NULL, pre_del_cb, NULL};
+ node_op_t op = {NULL, NULL, _pre_del_cb, NULL};
fdata* f;
fnode_event_t* ev;
int e;
if (!ev->is_pending) {
#ifdef GIO_COMPILATION
if (ev->has_twin) {
- fdata_emit_events (f, FILE_ATTRIB);
+ _fdata_emit_events (f, FILE_ATTRIB);
}
#endif
- fdata_emit_events (f, ev->e);
+ _fdata_emit_events (f, ev->e);
}
- fnode_event_delete (ev);
+ _fnode_event_delete (ev);
ev = NULL;
/* Adjust node state. */
break;
case FILE_ATTRIB:
g_assert (f->change_update_id == 0);
- if (!port_add (&f->fobj, &f->len, f)) {
- ev = fnode_event_new (FILE_DELETE, FALSE, f);
+ if (!_port_add (&f->fobj, &f->len, f)) {
+ ev = _fnode_event_new (FILE_DELETE, FALSE, f);
if (ev != NULL) {
- fdata_add_event (f, ev);
+ _fdata_add_event (f, ev);
}
}
break;
}
/**
- * fdata_add_event:
+ * _fdata_add_event:
*
*/
void
-fdata_add_event (fdata *f, fnode_event_t *ev)
+_fdata_add_event (fdata *f, fnode_event_t *ev)
{
- node_op_t op = {NULL, NULL, pre_del_cb, NULL};
+ node_op_t op = {NULL, NULL, _pre_del_cb, NULL};
fnode_event_t *tail;
if (!FN_IS_LIVING(f)) {
- fnode_event_delete (ev);
+ _fnode_event_delete (ev);
return;
}
case FILE_RENAME_FROM:
case FILE_RENAME_TO:
case FILE_ACCESS:
- fnode_event_delete (ev);
+ _fnode_event_delete (ev);
g_assert_not_reached ();
return;
case FILE_DELETE:
if (tail) {
g_queue_pop_tail (f->eventq);
do {
- fnode_event_delete (tail);
+ _fnode_event_delete (tail);
} while ((tail = (fnode_event_t*)g_queue_pop_tail (f->eventq)) != NULL);
}
/*
* Given a node "f" is deleted, process it ASAP.
*/
- fdata_emit_events (f, ev->e);
- fnode_event_delete (ev);
- fdata_adjust_deleted (f);
+ _fdata_emit_events (f, ev->e);
+ _fnode_event_delete (ev);
+ _fdata_adjust_deleted (f);
return;
case FILE_MODIFIED:
case UNMOUNTED:
g_time_val_add (&ev->t, PAIR_EVENTS_INC_TIMEVAL);
/* skip the previous event */
FD_W ("SKIPPED -- %s\n", _event_string (tail->e));
- fnode_event_delete (tail);
+ _fnode_event_delete (tail);
} else {
break;
}
} else if (ev->e == FILE_MODIFIED && tail->e == FILE_ATTRIB) {
ev->has_twin = TRUE;
- fnode_event_delete (tail);
+ _fnode_event_delete (tail);
} else if (ev->e == FILE_ATTRIB && f->change_update_id > 0) {
tail->has_twin = TRUE;
/* skip the current event */
- fnode_event_delete (ev);
+ _fnode_event_delete (ev);
return;
} else {
break;
}
gboolean
-fdata_class_init (void (*user_emit_cb) (fdata*, int),
+_fdata_class_init (void (*user_emit_cb) (fdata*, int),
void (*user_emit_once_cb) (fdata*, int, gpointer),
int (*user_event_converter) (int event))
{
emit_once_cb = user_emit_once_cb;
_event_converter = user_event_converter;
- if (!port_class_init (fdata_add_event)) {
- FD_W ("port_class_init failed.");
+ if (!_port_class_init (_fdata_add_event)) {
+ FD_W ("_port_class_init failed.");
return FALSE;
}
return TRUE;
} fdata;
/* fdata functions */
-fdata* fdata_new (node_t* node, gboolean is_mondir);
-void fdata_reset (fdata* data);
-void fdata_emit_events_once (fdata *f, int event, gpointer sub);
-void fdata_emit_events (fdata *f, int event);
-void fdata_add_event (fdata *f, fnode_event_t *ev);
-void fdata_adjust_deleted (fdata *f);
-fdata* get_parent_data (fdata* data);
-node_t* get_parent_node (fdata* data);
-gboolean is_monitoring (fdata* data);
+fdata* _fdata_new (node_t* node, gboolean is_mondir);
+void _fdata_reset (fdata* data);
+void _fdata_emit_events_once (fdata *f, int event, gpointer sub);
+void _fdata_emit_events (fdata *f, int event);
+void _fdata_add_event (fdata *f, fnode_event_t *ev);
+void _fdata_adjust_deleted (fdata *f);
+fdata* _get_parent_data (fdata* data);
+node_t* _get_parent_node (fdata* data);
+gboolean _is_monitoring (fdata* data);
/* sub */
-void fdata_sub_add (fdata *f, gpointer sub);
-void fdata_sub_remove (fdata *f, gpointer sub);
+void _fdata_sub_add (fdata *f, gpointer sub);
+void _fdata_sub_remove (fdata *f, gpointer sub);
/* misc */
-node_t* add_missing_cb (node_t* parent, gpointer user_data);
-gboolean pre_del_cb (node_t* node, gpointer user_data);
+node_t* _add_missing_cb (node_t* parent, gpointer user_data);
+gboolean _pre_del_cb (node_t* node, gpointer user_data);
/* init */
-gboolean fdata_class_init (void (*user_emit_cb) (fdata*, int),
+gboolean _fdata_class_init (void (*user_emit_cb) (fdata*, int),
void (*user_emit_once_cb) (fdata*, int, gpointer),
int (*user_event_converter) (int event));
GList* i;
if (G_TRYLOCK (fen_lock)) {
if (node) {
- travel_nodes (node, &op);
+ _travel_nodes (node, &op);
}
G_UNLOCK (fen_lock);
}
{
GDir *dir;
GError *err = NULL;
- node_op_t op = {NULL, NULL, pre_del_cb, NULL};
+ node_op_t op = {NULL, NULL, _pre_del_cb, NULL};
fdata* pdata;
FH_W ("%s %s [0x%p]\n", __func__, NODE_NAME(f), f);
- pdata = node_get_data (f);
+ pdata = _node_get_data (f);
dir = g_dir_open (NODE_NAME(f), 0, &err);
if (dir) {
fdata* data;
GList *idx;
- childf = children_find (f, basename);
+ childf = _children_find (f, basename);
if (childf == NULL) {
gchar *filename;
filename = g_build_filename (NODE_NAME(f), basename, NULL);
- childf = add_node (f, filename);
+ childf = _add_node (f, filename);
g_assert (childf);
g_free (filename);
}
- if ((data = node_get_data (childf)) == NULL) {
- data = fdata_new (childf, FALSE);
+ if ((data = _node_get_data (childf)) == NULL) {
+ data = _fdata_new (childf, FALSE);
}
if (is_monitoring (data)) {
/* Ignored */
- } else if (/* !is_ported (data) && */
- port_add (&data->fobj, &data->len, data)) {
+ } else if (/* !_is_ported (data) && */
+ _port_add (&data->fobj, &data->len, data)) {
/* Emit created to all other subs */
- fdata_emit_events (data, FN_EVENT_CREATED);
+ _fdata_emit_events (data, FN_EVENT_CREATED);
}
/* Emit created to the new sub */
#ifdef GIO_COMPILATION
- /* fdata_emit_events_once (data, FN_EVENT_CREATED, sub); */
+ /* _fdata_emit_events_once (data, FN_EVENT_CREATED, sub); */
#else
gam_server_emit_one_event (NODE_NAME(childf),
gam_subscription_is_dir (sub), GAMIN_EVENT_EXISTS, sub, 1);
}
/**
- * fen_add
+ * _fen_add
*
* Won't hold a ref, we have a timout callback to clean unused fdata.
* If there is no value for a key, add it and return it; else return the old
* one.
*/
void
-fen_add (const gchar *filename, gpointer sub, gboolean is_mondir)
+_fen_add (const gchar *filename, gpointer sub, gboolean is_mondir)
{
- node_op_t op = {NULL, add_missing_cb, pre_del_cb, (gpointer)filename};
+ node_op_t op = {NULL, _add_missing_cb, _pre_del_cb, (gpointer)filename};
node_t* f;
fdata* data;
g_assert (sub);
G_LOCK (fen_lock);
- f = find_node_full (filename, &op);
+ f = _find_node_full (filename, &op);
FH_W ("[ %s ] f[0x%p] sub[0x%p] %s\n", __func__, f, sub, filename);
g_assert (f);
- data = node_get_data (f);
+ data = _node_get_data (f);
if (data == NULL) {
- data = fdata_new (f, is_mondir);
+ data = _fdata_new (f, is_mondir);
}
if (is_mondir) {
/* Change to active */
#ifdef GIO_COMPILATION
- if (port_add (&data->fobj, &data->len, data) ||
+ if (_port_add (&data->fobj, &data->len, data) ||
g_file_test (FN_NAME(data), G_FILE_TEST_EXISTS)) {
if (is_mondir) {
scan_children_init (f, sub);
}
- fdata_sub_add (data, sub);
+ _fdata_sub_add (data, sub);
} else {
- fdata_sub_add (data, sub);
- fdata_adjust_deleted (data);
+ _fdata_sub_add (data, sub);
+ _fdata_adjust_deleted (data);
}
#else
- if (port_add (&data->fobj, &data->len, data) ||
+ if (_port_add (&data->fobj, &data->len, data) ||
g_file_test (FN_NAME(data), G_FILE_TEST_EXISTS)) {
gam_server_emit_one_event (FN_NAME(data),
gam_subscription_is_dir (sub), GAMIN_EVENT_EXISTS, sub, 1);
}
gam_server_emit_one_event (FN_NAME(data),
gam_subscription_is_dir (sub), GAMIN_EVENT_ENDEXISTS, sub, 1);
- fdata_sub_add (data, sub);
+ _fdata_sub_add (data, sub);
} else {
- fdata_sub_add (data, sub);
+ _fdata_sub_add (data, sub);
gam_server_emit_one_event (FN_NAME(data),
gam_subscription_is_dir (sub), GAMIN_EVENT_DELETED, sub, 1);
- fdata_adjust_deleted (data);
+ _fdata_adjust_deleted (data);
gam_server_emit_one_event (FN_NAME(data),
gam_subscription_is_dir (sub), GAMIN_EVENT_ENDEXISTS, sub, 1);
}
}
void
-fen_remove (const gchar *filename, gpointer sub, gboolean is_mondir)
+_fen_remove (const gchar *filename, gpointer sub, gboolean is_mondir)
{
- node_op_t op = {NULL, add_missing_cb, pre_del_cb, (gpointer)filename};
+ node_op_t op = {NULL, _add_missing_cb, _pre_del_cb, (gpointer)filename};
node_t* f;
fdata* data;
g_assert (sub);
G_LOCK (fen_lock);
- f = find_node (filename);
+ f = _find_node (filename);
FH_W ("[ %s ] f[0x%p] sub[0x%p] %s\n", __func__, f, sub, filename);
g_assert (f);
- data = node_get_data (f);
+ data = _node_get_data (f);
g_assert (data);
if (is_mondir) {
data->mon_dir_num --;
}
- fdata_sub_remove (data, sub);
+ _fdata_sub_remove (data, sub);
if (FN_IS_PASSIVE(data)) {
#ifdef GIO_COMPILATION
- pending_remove_node (f, &op);
+ _pending_remove_node (f, &op);
#else
- remove_node (f, &op);
+ _remove_node (f, &op);
#endif
}
G_UNLOCK (fen_lock);
fen_init_once_func (gpointer data)
{
FH_W ("%s\n", __func__);
- if (!node_class_init ()) {
- FH_W ("node_class_init failed.");
+ if (!_node_class_init ()) {
+ FH_W ("_node_class_init failed.");
return FALSE;
}
- if (!fdata_class_init (default_emit_event_cb,
+ if (!_fdata_class_init (default_emit_event_cb,
default_emit_once_event_cb,
default_event_converter)) {
- FH_W ("fdata_class_init failed.");
+ FH_W ("_fdata_class_init failed.");
return FALSE;
}
return TRUE;
}
gboolean
-fen_init ()
+_fen_init ()
{
#ifdef GIO_COMPILATION
static GOnce fen_init_once = G_ONCE_INIT;
child, NULL, events);
}
}
- if ((pdata = get_parent_data (f)) != NULL) {
+ if ((pdata = _get_parent_data (f)) != NULL) {
for (i = pdata->subs; i; i = i->next) {
fen_sub* sub = (fen_sub*)i->data;
gboolean file_is_dir = sub->is_mondir;
gam_server_emit_one_event (FN_NAME(f), file_is_dir, events, i->data, 1);
}
}
- if ((pdata = get_parent_data (f)) != NULL) {
+ if ((pdata = _get_parent_data (f)) != NULL) {
for (i = pdata->subs; i; i = i->next) {
gboolean file_is_dir = gam_subscription_is_dir (i->data);
gam_server_emit_one_event (FN_NAME(f), file_is_dir, events, i->data, 1);
#ifndef _FEN_HELPER_H_
#define _FEN_HELPER_H_
-void fen_add (const gchar *filename, gpointer sub, gboolean is_mondir);
-void fen_remove (const gchar *filename, gpointer sub, gboolean is_mondir);
+void _fen_add (const gchar *filename, gpointer sub, gboolean is_mondir);
+void _fen_remove (const gchar *filename, gpointer sub, gboolean is_mondir);
/* FEN subsystem initializing */
-gboolean fen_init ();
+gboolean _fen_init ();
#endif /* _FEN_HELPER_H_ */
static void pnode_delete (pnode_t *pn);
gboolean
-is_ported (gpointer f)
+_is_ported (gpointer f)
{
_f* fo = g_hash_table_lookup (_obj_fen_hash, f);
}
}
- if ((ev = fnode_event_new (e, has_twin, f)) != NULL) {
+ if ((ev = _fnode_event_new (e, has_twin, f)) != NULL) {
g_queue_push_tail (g_eventq, ev);
}
}
return pn;
}
-/**
+/*
* port_add_internal
*
* < private >
}
gboolean
-port_add (file_obj_t* fobj, off_t* len, gpointer f)
+_port_add (file_obj_t* fobj, off_t* len, gpointer f)
{
return port_add_internal (fobj, len, f, TRUE);
}
gboolean
-port_add_simple (file_obj_t* fobj, gpointer f)
+_port_add_simple (file_obj_t* fobj, gpointer f)
{
return port_add_internal (fobj, NULL, f, FALSE);
}
-/**
- * port_remove
+/*
+ * port_remove:
*
* < private >
* Unsafe, need lock fen_lock.
*/
void
-port_remove (gpointer f)
+_port_remove (gpointer f)
{
_f* fo = NULL;
*/
extern gboolean
-port_class_init (void (*user_add_event) (gpointer, fnode_event_t*))
+_port_class_init (void (*user_add_event) (gpointer, fnode_event_t*))
{
rctlblk_t *rblk;
FK_W ("%s\n", __func__);
}
fnode_event_t*
-fnode_event_new (int event, gboolean has_twin, gpointer user_data)
+_fnode_event_new (int event, gboolean has_twin, gpointer user_data)
{
fnode_event_t *ev;
}
void
-fnode_event_delete (fnode_event_t* ev)
+_fnode_event_delete (fnode_event_t* ev)
{
g_free (ev);
}
GTimeVal t;
} fnode_event_t;
-gboolean port_add (file_obj_t* fobj, off_t* len, gpointer f);
-gboolean port_add_simple (file_obj_t* fobj, gpointer f);
-void port_remove (gpointer f);
-gboolean is_ported (gpointer f);
+gboolean _port_add (file_obj_t* fobj, off_t* len, gpointer f);
+gboolean _port_add_simple (file_obj_t* fobj, gpointer f);
+void _port_remove (gpointer f);
+gboolean _is_ported (gpointer f);
-fnode_event_t* fnode_event_new (int event, gboolean has_twin, gpointer user_data);
-void fnode_event_delete (fnode_event_t* ev);
+fnode_event_t* _fnode_event_new (int event, gboolean has_twin, gpointer user_data);
+void _fnode_event_delete (fnode_event_t* ev);
const gchar * _event_string (int event);
-extern gboolean port_class_init ();
+extern gboolean _port_class_init ();
#endif /* _FEN_KERNEL_H_ */
for (idx = missing_list; idx; idx = idx->next) {
f = (fdata*)idx->data;
- if (port_add (&f->fobj, &f->len, f)) {
+ if (_port_add (&f->fobj, &f->len, f)) {
/* TODO - emit CREATE event */
- fdata_emit_events (f, FN_EVENT_CREATED);
+ _fdata_emit_events (f, FN_EVENT_CREATED);
existing_list = g_list_prepend (existing_list, idx);
}
}
* Unsafe, need lock fen_lock.
*/
void
-missing_add (fdata *f)
+_missing_add (fdata *f)
{
GList *idx;
- g_assert (!is_ported (f));
+ g_assert (!_is_ported (f));
if (g_list_find (missing_list, f) != NULL) {
FM_W ("%s is ALREADY added %s\n", __func__, FN_NAME(f));
* Unsafe, need lock fen_lock.
*/
void
-missing_remove (fdata *f)
+_missing_remove (fdata *f)
{
FM_W ("%s %s\n", __func__, FN_NAME(f));
missing_list = g_list_remove (missing_list, f);
G_BEGIN_DECLS
-extern void missing_add (fdata *f);
-extern void missing_remove (fdata *f);
+extern void _missing_add (fdata *f);
+extern void _missing_remove (fdata *f);
G_END_DECLS
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) {
+ if ((node = _find_node (d->filename)) != NULL) {
remove_node_internal (node, d->op);
}
_dnode_free (d);
}
gpointer
-node_get_data (node_t* node)
+_node_get_data (node_t* node)
{
g_assert (node);
return node->user_data;
}
gpointer
-node_set_data (node_t* node, gpointer user_data)
+_node_set_data (node_t* node, gpointer user_data)
{
gpointer data = node->user_data;
g_assert (node);
}
void
-travel_nodes (node_t* node, node_op_t* op)
+_travel_nodes (node_t* node, node_op_t* op)
{
GList* children;
GList* i;
children = g_hash_table_get_values (node->children);
if (children) {
for (i = children; i; i = i->next) {
- travel_nodes (i->data, op);
+ _travel_nodes (i->data, op);
}
g_list_free (children);
}
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);
+ child = _children_find (parent, token);
if (child) {
parent = child;
} else {
}
node_t*
-find_node (const gchar *filename)
+_find_node (const gchar *filename)
{
return find_node_internal (_head, filename, NULL);
}
node_t*
-find_node_full (const gchar* filename, node_op_t* op)
+_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)
+_add_node (node_t* parent, const gchar* filename)
{
gchar* str;
gchar* token;
}
}
-/**
+/*
* 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) {
+ if (_children_num (node) > 0) {
children_foreach_remove (node, children_remove_cb,
(gpointer)op);
}
- if (children_num (node) == 0) {
+ if (_children_num (node) == 0) {
return TRUE;
}
return FALSE;
parent = node->parent;
children_remove (parent, node);
node_delete (node);
- if (children_num (parent) == 0) {
+ if (_children_num (parent) == 0) {
remove_node_internal (parent, op);
}
return TRUE;
}
void
-pending_remove_node (node_t* node, node_op_t* op)
+_pending_remove_node (node_t* node, node_op_t* op)
{
struct _dnode* d;
GList* l;
}
void
-remove_node (node_t* node, node_op_t* op)
+_remove_node (node_t* node, node_op_t* op)
{
remove_node_internal (node, op);
}
}
guint
-children_num (node_t *f)
+_children_num (node_t *f)
{
return g_hash_table_size (f->children);
}
node_t *
-children_find (node_t *f, const gchar *basename)
+_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
}
gboolean
-node_class_init ()
+_node_class_init ()
{
FN_W ("%s\n", __func__);
if (_head == NULL) {
gpointer user_data;
} node_op_t;
-node_t* add_node (node_t* parent, const gchar* filename);
-void remove_node (node_t* node, node_op_t* op);
-void pending_remove_node (node_t* node, node_op_t* op);
+node_t* _add_node (node_t* parent, const gchar* filename);
+void _remove_node (node_t* node, node_op_t* op);
+void _pending_remove_node (node_t* node, node_op_t* op);
-void travel_nodes (node_t* node, node_op_t* op);
-node_t* find_node_full (const gchar* filename, node_op_t* op);
-node_t* find_node (const gchar *filename);
+void _travel_nodes (node_t* node, node_op_t* op);
+node_t* _find_node_full (const gchar* filename, node_op_t* op);
+node_t* _find_node (const gchar *filename);
-node_t* children_find (node_t *f, const gchar *basename);
-guint children_num (node_t *f);
+node_t* _children_find (node_t *f, const gchar *basename);
+guint _children_num (node_t *f);
-gpointer node_get_data (node_t* node);
-gpointer node_set_data (node_t* node, gpointer user_data);
+gpointer _node_get_data (node_t* node);
+gpointer _node_set_data (node_t* node, gpointer user_data);
-gboolean node_class_init ();
+gboolean _node_class_init ();
#endif /* _FEN_NODE_H_ */
#include "fen-sub.h"
fen_sub*
-fen_sub_new (gpointer udata, gboolean is_mondir)
+_fen_sub_new (gpointer udata, gboolean is_mondir)
{
fen_sub *sub;
sub = g_new (fen_sub, 1);
}
void
-fen_sub_delete (fen_sub *sub)
+_fen_sub_delete (fen_sub *sub)
{
g_free (sub);
}
gboolean is_mondir;
} fen_sub;
-fen_sub* fen_sub_new (gpointer udata, gboolean is_mondir);
-void fen_sub_delete (fen_sub *sub);
+fen_sub* _fen_sub_new (gpointer udata, gboolean is_mondir);
+void _fen_sub_delete (fen_sub *sub);
#endif _FEN_SUB_H_
GFenDirectoryMonitor *self = G_FEN_DIRECTORY_MONITOR (object);
if (self->sub) {
- fen_remove (G_LOCAL_DIRECTORY_MONITOR (self)->dirname, self->sub, TRUE);
- fen_sub_delete (self->sub);
+ _fen_remove (G_LOCAL_DIRECTORY_MONITOR (self)->dirname, self->sub, TRUE);
+ _fen_sub_delete (self->sub);
self->sub = NULL;
}
/* Will never fail as is_supported() should be called before instanciating
* anyway */
- if (!fen_init ())
+ if (!_fen_init ())
g_assert_not_reached ();
/* FIXME: what to do about errors here? we can't return NULL or another
* kind of error and an assertion is probably too hard */
- self->sub = fen_sub_new (self, TRUE);
+ self->sub = _fen_sub_new (self, TRUE);
g_assert (self->sub);
- fen_add (dirname, self->sub, TRUE);
+ _fen_add (dirname, self->sub, TRUE);
return obj;
}
static gboolean
g_fen_directory_monitor_is_supported (void)
{
- return fen_init ();
+ return _fen_init ();
}
static void
GFenDirectoryMonitor *self = G_FEN_DIRECTORY_MONITOR (monitor);
if (self->sub) {
- fen_remove (G_LOCAL_DIRECTORY_MONITOR (self)->dirname, self->sub, TRUE);
- fen_sub_delete (self->sub);
+ _fen_remove (G_LOCAL_DIRECTORY_MONITOR (self)->dirname, self->sub, TRUE);
+ _fen_sub_delete (self->sub);
self->sub = NULL;
}
GFenFileMonitor *self = G_FEN_FILE_MONITOR (object);
if (self->sub) {
- fen_remove (G_LOCAL_FILE_MONITOR (self)->filename, self->sub, FALSE);
- fen_sub_delete (self->sub);
+ _fen_remove (G_LOCAL_FILE_MONITOR (self)->filename, self->sub, FALSE);
+ _fen_sub_delete (self->sub);
self->sub = NULL;
}
/* Will never fail as is_supported() should be called before instanciating
* anyway */
- if (!fen_init ())
+ if (!_fen_init ())
g_assert_not_reached ();
/* FIXME: what to do about errors here? we can't return NULL or another
* kind of error and an assertion is probably too hard */
- self->sub = fen_sub_new (self, FALSE);
+ self->sub = _fen_sub_new (self, FALSE);
g_assert (self->sub);
- fen_add (filename, self->sub, FALSE);
+ _fen_add (filename, self->sub, FALSE);
return obj;
}
static gboolean
g_fen_file_monitor_is_supported (void)
{
- return fen_init ();
+ return _fen_init ();
}
static void
GFenFileMonitor *self = G_FEN_FILE_MONITOR (monitor);
if (self->sub) {
- fen_remove (G_LOCAL_FILE_MONITOR (self)->filename, self->sub, FALSE);
- fen_sub_delete (self->sub);
+ _fen_remove (G_LOCAL_FILE_MONITOR (self)->filename, self->sub, FALSE);
+ _fen_sub_delete (self->sub);
self->sub = NULL;
}
--- /dev/null
+# libfen_la-fen-dump.lo - a libtool object file
+# Generated by ltmain.sh - GNU libtool 1.5.26 (1.1220.2.493 2008/02/01 16:58:18)
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# Name of the PIC object.