vfs.h

Go to the documentation of this file.

/*
 * Copyright (c) 2006-2009 Ed Schouten <ed@80386.nl>
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
/*
 * All structures mentioned in this file are only directly dereferenced
 * in the VFS itself, so we could remove their declaration to a private
 * header file. The problem is that this results in worse performance,
 * especially on the vfs_list_* functions.
 */

struct vfsref;
struct vfsent;

struct vfslist {
        struct vfsref *first;
        struct vfsref *last;
        unsigned int items;
};

struct vfsmodule {
        int     (*match)(struct vfsent *ve, int isdir);
        int     (*populate)(struct vfsent *ve);
        FILE    *(*open)(struct vfsent *ve);

        char    pseudo;

        unsigned char sortorder;

        char    marking;
};

struct vfsent {
        char    *name;
        char    *filename;

        int     refcount;

        struct vfsmodule *vmod;
        struct vfslist population;
        int     recurse;
};

struct vfsref {
        struct vfsent *ent;
        struct vfsref *next;
        struct vfsref *prev;
        int marked;
};

struct vfsmatch {
        regex_t         regex;
        char            *string;
};

#define VFSLIST_INITIALIZER { NULL, NULL, 0 }

static inline void
vfs_list_init(struct vfslist *vl)
{
        vl->first = vl->last = NULL;
        vl->items = 0;
}

static inline void
vfs_list_move(struct vfslist *vdst, const struct vfslist *vsrc)
{
        memcpy(vdst, vsrc, sizeof(struct vfslist));
}

static inline struct vfsref *
vfs_list_first(const struct vfslist *vl)
{
        return (vl->first);
}

static inline struct vfsref *
vfs_list_last(const struct vfslist *vl)
{
        return (vl->last);
}

static inline int
vfs_list_empty(const struct vfslist *vl)
{
        return (vl->first == NULL);
}

static inline unsigned int
vfs_list_items(const struct vfslist *vl)
{
        return (vl->items);
}

static inline struct vfsref *
vfs_list_next(const struct vfsref *vr)
{
        return (vr->next);
}

static inline struct vfsref *
vfs_list_prev(const struct vfsref *vr)
{
        return (vr->prev);
}

#define VFS_LIST_FOREACH(vl, vr) \
        for (vr = vfs_list_first(vl); vr != NULL; vr = vfs_list_next(vr))

#define VFS_LIST_FOREACH_REVERSE(vl, vr) \
        for (vr = vfs_list_last(vl); vr != NULL; vr = vfs_list_prev(vr))

static inline void
vfs_list_remove(struct vfslist *vl, struct vfsref *vr)
{
        if (vr->next == NULL) {
                /* Item was the last in the list */
                g_assert(vl->last == vr);
                vl->last = vr->prev;
        } else {
                /* There is an item after this one */
                vr->next->prev = vr->prev;
        }
        if (vr->prev == NULL) {
                /* Item was the first in the list */
                g_assert(vl->first == vr);
                vl->first = vr->next;
        } else {
                /* There is an item before this one */
                vr->prev->next = vr->next;
        }
        vl->items--;
}

static inline void
vfs_list_insert_head(struct vfslist *vl, struct vfsref *vr)
{
        vr->prev = NULL;
        vr->next = vl->first;
        vl->first = vr;
        if (vr->next != NULL) {
                /* Item is stored before other ones */
                vr->next->prev = vr;
        } else {
                /* New item is only item in the list */
                vl->last = vr;
        }
        vl->items++;
}

static inline void
vfs_list_insert_tail(struct vfslist *vl, struct vfsref *vr)
{
        vr->prev = vl->last;
        vr->next = NULL;
        vl->last = vr;
        if (vr->prev != NULL) {
                /* Item is stored after other ones */
                vr->prev->next = vr;
        } else {
                /* New item is only item in the list */
                vl->first = vr;
        }
        vl->items++;
}

static inline void
vfs_list_insert_before(struct vfslist *vl, struct vfsref *nvr,
    struct vfsref *lvr)
{
        nvr->prev = lvr->prev;
        nvr->next = lvr;
        lvr->prev = nvr;
        if (nvr->prev != NULL) {
                /* Store item between two others */
                nvr->prev->next = nvr;
        } else {
                /* New item is added before the first one */
                vl->first = nvr;
        }
        vl->items++;
}

static inline void
vfs_list_insert_after(struct vfslist *vl, struct vfsref *nvr,
    struct vfsref *lvr)
{
        nvr->prev = lvr;
        nvr->next = lvr->next;
        lvr->next = nvr;
        if (nvr->next != NULL) {
                /* Store item between two others */
                nvr->next->prev = nvr;
        } else {
                /* New item is added after the first one */
                vl->last = nvr;
        }
        vl->items++;
}

const char      *vfs_lockup(void);

struct vfsref   *vfs_lookup(const char *filename, const char *name,
    const char *basepath, int strict);
struct vfsref   *vfs_dup(const struct vfsref *vr);
void            vfs_close(struct vfsref *vr);
int             vfs_populate(const struct vfsref *vr);
void            vfs_unfold(struct vfslist *vl, const struct vfsref *vr);
void            vfs_locate(struct vfslist *vl, const struct vfsref *vr,
    const struct vfsmatch *vm);
struct vfsref   *vfs_write_playlist(const struct vfslist *vl,
    const struct vfsref *vr, const char *filename);
int             vfs_delete(const char *filename);
FILE            *vfs_fopen(const char *filename, const char *mode);
int             vfs_fgets(char *str, size_t size, FILE *fp);

static inline const char *
vfs_name(const struct vfsref *vr)
{
        return (vr->ent->name);
}

static inline const char *
vfs_filename(const struct vfsref *vr)
{
        return (vr->ent->filename);
}

static inline int
vfs_playable(const struct vfsref *vr)
{
        return (vr->ent->vmod->open != NULL);
}

static inline FILE *
vfs_open(const struct vfsref *vr)
{
        return vr->ent->vmod->open(vr->ent);
}

static inline int
vfs_populatable(const struct vfsref *vr)
{
        return (vr->ent->vmod->populate != NULL);
}

static inline char
vfs_marking(const struct vfsref *vr)
{
        return (vr->ent->vmod->marking);
}

static inline const struct vfslist *
vfs_population(const struct vfsref *vr)
{
        return (&vr->ent->population);
}

static inline int
vfs_marked(const struct vfsref *vr)
{
        return (vr->marked != 0);
}

static inline void
vfs_mark(struct vfsref *vr)
{
        vr->marked = 1;
}

static inline void
vfs_unmark(struct vfsref *vr)
{
        vr->marked = 0;
}

struct vfsmatch *vfs_match_new(const char *str);
void            vfs_match_free(struct vfsmatch *vm);

static inline int
vfs_match_compare(const struct vfsmatch *vm, const char *name)
{
        return (regexec(&vm->regex, name, 0, NULL, 0) == 0);
}

static inline const char *
vfs_match_value(const struct vfsmatch *vm)
{
        return (vm->string);
}

---