provider.h

Go to the documentation of this file.

#ifndef _STATEFS_PROVIDER_H_
#define _STATEFS_PROVIDER_H_

#include <sys/types.h>
#include <stdbool.h>
#include <stdint.h>
#include <stddef.h>

#ifdef __cplusplus
#define EXTERN_C_BEGIN extern "C" {
#define EXTERN_C_END }
#define EXTERN_C extern "C"
#else
#define EXTERN_C_BEGIN
#define EXTERN_C_END
#define EXTERN_C
#endif

EXTERN_C_BEGIN

typedef unsigned long statefs_size_t;
typedef long statefs_ssize_t;
typedef unsigned long statefs_off_t;
typedef intptr_t statefs_handle_t;

typedef enum
{
    statefs_variant_int,
    statefs_variant_uint,
    statefs_variant_bool,
    statefs_variant_real,
    statefs_variant_cstr,

    statefs_variant_tags_end
} statefs_variant_tag;

struct statefs_variant
{
    statefs_variant_tag tag;
    union
    {
        long i;
        unsigned long u;
        bool b;
        double r;
        char const *s;
    };
};

#define STATEFS_INT(v) { .tag = statefs_variant_int, .i = (v) }
#define STATEFS_UINT(v) { .tag = statefs_variant_uint, .i = (v) }
#define STATEFS_REAL(v) { .tag = statefs_variant_real, .r = (v) }
#define STATEFS_BOOL(v) { .tag = statefs_variant_bool, .b = (v) }
#define STATEFS_CSTR(v) { .tag = statefs_variant_cstr, .s = (v) }

struct statefs_meta
{
    char const *name; 
    struct statefs_variant value; 
};

typedef enum
{
    statefs_node_prop = 1,
    statefs_node_ns = 2,
    statefs_node_root = statefs_node_ns | 4
} statefs_node_type;

struct statefs_node
{
    statefs_node_type type;
    char const *name;
    void (*release)(struct statefs_node*);
    struct statefs_meta const* info;
};

struct statefs_branch
{
    struct statefs_node * (*find)(struct statefs_branch const*, char const *);
    statefs_handle_t (*first)(struct statefs_branch const*);
    void (*next)(struct statefs_branch const*, statefs_handle_t *);
    struct statefs_node * (*get)(struct statefs_branch const*, statefs_handle_t);
    bool (*release)(struct statefs_branch const*, statefs_handle_t);
};

struct statefs_property;

struct statefs_slot
{
    void (*on_changed)(struct statefs_slot *,
                       struct statefs_property *);
};

struct statefs_property
{
    struct statefs_node node;
    struct statefs_variant default_value;
};

#define STATEFS_ATTR_READ (1)

#define STATEFS_ATTR_WRITE (1 << 1)

#define STATEFS_ATTR_DISCRETE (1 << 2)

struct statefs_io
{
    int (*getattr)(struct statefs_property const *);

    statefs_ssize_t (*size)(struct statefs_property const *);

    statefs_handle_t (*open)(struct statefs_property *self, int flags);

    int (*read)(statefs_handle_t h, char *dst, statefs_size_t len, statefs_off_t off);

    int (*write)(statefs_handle_t, char const*, statefs_size_t, statefs_off_t);

    void (*close)(statefs_handle_t);

    bool (*connect)(struct statefs_property *, struct statefs_slot *);
    void (*disconnect)(struct statefs_property *);
};

struct statefs_namespace
{
    struct statefs_node node;
    struct statefs_branch branch;
};

struct statefs_provider
{
    unsigned version;

    struct statefs_namespace root;

    struct statefs_io io;
};


typedef enum {
    statefs_event_reload,

    // add new events above
    statefs_events_end
}  statefs_event;

struct statefs_server
{
    void (*event)(struct statefs_server*
                  , struct statefs_provider*
                  , statefs_event);
};

typedef struct statefs_provider * (*statefs_provider_fn)
    (struct statefs_server*);

struct statefs_provider * statefs_provider_get(struct statefs_server*);

static inline char const *statefs_provider_accessor()
{
    return "statefs_provider_get";
}

#define STATEFS_MK_VERSION(major, minor)                                \
    (((unsigned)major << (sizeof(unsigned) * 4)) | ((unsigned)minor))

#define STATEFS_GET_VERSION(version, major, minor)                      \
    do {                                                                \
        major = (version) >> (sizeof(unsigned) * 4);                    \
        minor = (version) & ((unsigned)-1 >> (sizeof(unsigned) * 4));   \
    } while (0)

/* increase minor version for backward compatible providers, major -
 * if provider logic is changed and it can't be used with previous
 * versions of consumer safely
 */
#define STATEFS_CURRENT_VERSION STATEFS_MK_VERSION(3, 0)

static inline bool statefs_is_version_compatible
(unsigned own_version, unsigned lib_ver)
{
    unsigned short maj, min;
    unsigned short prov_maj, prov_min;
    STATEFS_GET_VERSION(lib_ver, prov_maj, prov_min);
    STATEFS_GET_VERSION(own_version, maj, min);
    return (prov_maj == maj) && (prov_min <= min);
}

static inline bool statefs_is_compatible
(unsigned own_version, struct statefs_provider *provider)
{
    return statefs_is_version_compatible(own_version, provider->version);
}

EXTERN_C_END

#endif // _STATEFS_PROVIDER_H_