gp_dir_cache.h

Go to the documentation of this file.

//SPDX-License-Identifier: LGPL-2.0-or-later
 
/*
 
   Copyright (c) 2014-2022 Cyril Hrubis <metan@ucw.cz>
 
 */
 
#ifndef GP_DIR_CACHE_H
#define GP_DIR_CACHE_H
 
#include <utils/gp_poll.h>
#include <time.h>
 
typedef struct gp_dir_entry {
        size_t size;
        time_t mtime;
        unsigned int name_len;
        int is_dir:1;
        int filtered:1;
        char name[];
} gp_dir_entry;
 
typedef enum gp_dir_cache_sort_type {
        GP_DIR_SORT_ASC = 0x00,
        GP_DIR_SORT_DESC = 0x04,
        GP_DIR_SORT_BY_NAME = 0x00,
        GP_DIR_SORT_BY_SIZE = 0x01,
        GP_DIR_SORT_BY_MTIME = 0x02,
} gp_dir_cache_sort_type;
 
typedef struct gp_dir_cache {
        enum gp_dir_cache_sort_type sort_type;
        struct gp_balloc_pool *allocator;
        size_t filtered;
        size_t size;
        size_t used;
        gp_dir_entry **entries;
} gp_dir_cache;
 
gp_dir_cache *gp_dir_cache_new(const char *path);
 
void gp_dir_cache_destroy(gp_dir_cache *self);
 
gp_dir_entry *gp_dir_cache_add_entry(gp_dir_cache *self, size_t size,
                                     const char *name, mode_t mode, time_t mtime);
 
int gp_dir_cache_rem_entry_by_name(gp_dir_cache *self, const char *name);
 
gp_dir_entry *gp_dir_cache_entry_lookup(gp_dir_cache *self, const char *name);
 
int gp_dir_cache_entry_name_contains(gp_dir_cache *self, const char *needle);
 
void gp_dir_cache_free_entries(gp_dir_cache *self);
 
void gp_dir_cache_sort(gp_dir_cache *self, gp_dir_cache_sort_type sort_type);
 
static inline gp_dir_entry *gp_dir_cache_get(gp_dir_cache *self,
                                             unsigned int pos)
{
        if (self->used <= pos)
                return NULL;
 
        return self->entries[pos];
}
 
static inline void gp_dir_cache_set_filter(gp_dir_cache *self, unsigned int pos,
                                           int filter)
{
        if (self->entries[pos]->filtered == !!filter)
                return;
 
        self->entries[pos]->filtered = !!filter;
        self->filtered += filter ? 1 : -1;
}
 
static inline size_t gp_dir_cache_entries(gp_dir_cache *self)
{
        return self->used;
}
 
static inline size_t gp_dir_cache_entries_filter(gp_dir_cache *self)
{
        return self->used - self->filtered;
}
 
gp_dir_entry *gp_dir_cache_get_filtered(gp_dir_cache *self, unsigned int pos);
 
int gp_dir_cache_notify(gp_dir_cache *self);
 
gp_fd *gp_dir_cache_notify_fd(gp_dir_cache *self);
 
int gp_dir_cache_mkdir(gp_dir_cache *self, const char *dirname);
 
unsigned int gp_dir_cache_pos_by_name_filtered(gp_dir_cache *self, const char *name);
 
enum gp_dir_cache_type {
        GP_DIR_CACHE_NONE = 0,
        GP_DIR_CACHE_FILE = 1,
        GP_DIR_CACHE_DIR = 2,
};
 
enum gp_dir_cache_type gp_dir_cache_lookup(gp_dir_cache *self, const char *name);
 
#endif /* GP_DIR_CACHE_H */