sol-vector.h

Go to the documentation of this file.

/*
 * This file is part of the Soletta (TM) Project
 *
 * Copyright (C) 2015 Intel Corporation. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#pragma once

#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <errno.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef struct sol_vector {
    void *data; 
    uint16_t len; 
    uint16_t elem_size; 
} sol_vector;


#define SOL_VECTOR_INIT(TYPE) { NULL, 0, sizeof(TYPE) }

void sol_vector_init(struct sol_vector *v, uint16_t elem_size);

void *sol_vector_append(struct sol_vector *v);

void *sol_vector_append_n(struct sol_vector *v, uint16_t n);

static inline void *
sol_vector_get_no_check(const struct sol_vector *v, uint16_t i)
{
    const unsigned char *data;

    data = (const unsigned char *)v->data;

    return (void *)&data[v->elem_size * i];
}

static inline void *
sol_vector_get(const struct sol_vector *v, uint16_t i)
{
    if (i >= v->len)
        return NULL;

    return sol_vector_get_no_check(v, i);
}

int sol_vector_del(struct sol_vector *v, uint16_t i);

int sol_vector_del_element(struct sol_vector *v, const void *elem);

static inline int
sol_vector_del_last(struct sol_vector *v)
{
    if (v->len == 0)
        return 0;
    return sol_vector_del(v, v->len - 1);
}

int sol_vector_del_range(struct sol_vector *v, uint16_t start, uint16_t len);

void sol_vector_clear(struct sol_vector *v);

static inline void *
sol_vector_steal_data(struct sol_vector *v)
{
    void *data = v->data;

    v->data = NULL;
    v->len = 0;
    return data;
}

#define SOL_VECTOR_FOREACH_IDX(vector, itrvar, idx) \
    for (idx = 0; \
        idx < (vector)->len && (itrvar = (__typeof__(itrvar))sol_vector_get_no_check((vector), idx), true); \
        idx++)

#define SOL_VECTOR_FOREACH_IDX_UNTIL(vector, itrvar, idx, until) \
    for (idx = 0; \
        idx < until && (itrvar = (__typeof__(itrvar))sol_vector_get_no_check((vector), idx), true); \
        idx++)

#define SOL_VECTOR_FOREACH_REVERSE_IDX(vector, itrvar, idx) \
    for (idx = (vector)->len - 1; \
        idx != ((__typeof__(idx)) - 1) && (itrvar = (__typeof__(itrvar))sol_vector_get_no_check((vector), idx), true); \
        idx--)

typedef struct sol_ptr_vector {
    struct sol_vector base;
} sol_ptr_vector;

#define SOL_PTR_VECTOR_INIT { { NULL, 0, sizeof(void *) } }

static inline void
sol_ptr_vector_init(struct sol_ptr_vector *pv)
{
    sol_vector_init(&pv->base, sizeof(void *));
}

int sol_ptr_vector_init_n(struct sol_ptr_vector *pv, uint16_t n);

static inline uint16_t
sol_ptr_vector_get_len(const struct sol_ptr_vector *pv)
{
    return pv->base.len;
}

int sol_ptr_vector_append(struct sol_ptr_vector *pv, const void *ptr);

static inline void *
sol_ptr_vector_get_no_check(const struct sol_ptr_vector *pv, uint16_t i)
{
    void **data;

    data = (void **)sol_vector_get_no_check(&pv->base, i);
    return *data;
}

static inline void *
sol_ptr_vector_get(const struct sol_ptr_vector *pv, uint16_t i)
{
    if (i >= pv->base.len)
        return NULL;

    return sol_ptr_vector_get_no_check(pv, i);
}

int sol_ptr_vector_set(struct sol_ptr_vector *pv, uint16_t i, const void *ptr);

int32_t sol_ptr_vector_insert_sorted(struct sol_ptr_vector *pv, const void *ptr, int (*compare_cb)(const void *data1, const void *data2));

int32_t sol_ptr_vector_update_sorted(struct sol_ptr_vector *pv, uint16_t i, int (*compare_cb)(const void *data1, const void *data2));

int sol_ptr_vector_insert_at(struct sol_ptr_vector *pv, uint16_t i, const void *ptr);

int sol_ptr_vector_remove(struct sol_ptr_vector *pv, const void *ptr);

static inline int
sol_ptr_vector_del(struct sol_ptr_vector *pv, uint16_t i)
{
    return sol_vector_del(&pv->base, i);
}

static inline int
sol_ptr_vector_del_range(struct sol_ptr_vector *pv, uint16_t start, uint16_t len)
{
    return sol_vector_del_range(&pv->base, start, len);
}

int sol_ptr_vector_del_element(struct sol_ptr_vector *pv, const void *elem);

static inline int
sol_ptr_vector_del_last(struct sol_ptr_vector *pv)
{
    if (pv->base.len == 0)
        return 0;
    return sol_ptr_vector_del(pv, pv->base.len - 1);
}

static inline void *
sol_ptr_vector_steal(struct sol_ptr_vector *pv, uint16_t i)
{
    void *result = sol_ptr_vector_get(pv, i);

    sol_ptr_vector_del(pv, i);
    return result;
}

static inline void *
sol_ptr_vector_steal_last(struct sol_ptr_vector *pv)
{
    if (pv->base.len == 0)
        return NULL;
    return sol_ptr_vector_steal(pv, pv->base.len - 1);
}

static inline void
sol_ptr_vector_clear(struct sol_ptr_vector *pv)
{
    sol_vector_clear(&pv->base);
}

static inline void *
sol_ptr_vector_steal_data(struct sol_ptr_vector *pv)
{
    return sol_vector_steal_data(&pv->base);
}

#define SOL_PTR_VECTOR_FOREACH_IDX(vector, itrvar, idx) \
    for (idx = 0; \
        idx < (vector)->base.len && \
        ((itrvar = (__typeof__(itrvar))sol_ptr_vector_get_no_check((vector), idx)), true); \
        idx++)

#define SOL_PTR_VECTOR_FOREACH_IDX_UNTIL(vector, itrvar, idx, until) \
    for (idx = 0; \
        idx < until && \
        ((itrvar = (__typeof__(itrvar))sol_ptr_vector_get_no_check((vector), idx)), true); \
        idx++)

#define SOL_PTR_VECTOR_FOREACH_REVERSE_IDX(vector, itrvar, idx) \
    for (idx = (vector)->base.len - 1; \
        idx != ((__typeof__(idx)) - 1) && \
        (itrvar = (__typeof__(itrvar))sol_ptr_vector_get_no_check((vector), idx), true); \
        idx--)

static inline int32_t
sol_ptr_vector_find_last(const struct sol_ptr_vector *pv, const void *elem)
{
    uint16_t i;
    const void *p;

    SOL_PTR_VECTOR_FOREACH_REVERSE_IDX (pv, p, i) {
        if (elem == p)
            return i;
    }

    return -ENODATA;
}

static inline int32_t
sol_ptr_vector_find_first(const struct sol_ptr_vector *pv, const void *elem)
{
    uint16_t i;
    const void *p;

    SOL_PTR_VECTOR_FOREACH_IDX (pv, p, i) {
        if (elem == p)
            return i;
    }

    return -ENODATA;
}

static inline int32_t
sol_ptr_vector_match_first(const struct sol_ptr_vector *pv, const void *tempt, int (*compare_cb)(const void *data1, const void *data2))
{
    uint16_t i;
    const void *p;

    SOL_PTR_VECTOR_FOREACH_IDX (pv, p, i) {
        if (compare_cb(tempt, p) == 0)
            return i;
    }

    return -ENODATA;
}

static inline int32_t
sol_ptr_vector_match_last(const struct sol_ptr_vector *pv, const void *tempt, int (*compare_cb)(const void *data1, const void *data2))
{
    uint16_t i;
    const void *p;

    SOL_PTR_VECTOR_FOREACH_REVERSE_IDX (pv, p, i) {
        if (compare_cb(tempt, p) == 0)
            return i;
    }

    return -ENODATA;
}

int32_t sol_ptr_vector_match_sorted(const struct sol_ptr_vector *pv, const void *tempt, int (*compare_cb)(const void *data1, const void *data2));

static inline int32_t
sol_ptr_vector_find_sorted(const struct sol_ptr_vector *pv, const void *elem, int (*compare_cb)(const void *data1, const void *data2))
{
    uint16_t i;
    int32_t r;

    r = sol_ptr_vector_match_sorted(pv, elem, compare_cb);
    if (r < 0)
        return r;

    for (i = r; i < pv->base.len; i++) {
        const void *other = sol_ptr_vector_get_no_check(pv, i);

        if (compare_cb(elem, other) != 0)
            break;

        if (elem == other)
            return i;
    }

    for (i = r; i > 0; i--) {
        const void *other = sol_ptr_vector_get_no_check(pv, i - 1);

        if (compare_cb(elem, other) != 0)
            break;

        if (elem == other)
            return i - 1;
    }

    return -ENODATA;
}

static inline int32_t
sol_ptr_vector_find_last_sorted(const struct sol_ptr_vector *pv, const void *elem, int (*compare_cb)(const void *data1, const void *data2))
{
    uint16_t i;
    int32_t r, found_i = -ENODATA;

    r = sol_ptr_vector_match_sorted(pv, elem, compare_cb);
    if (r < 0)
        return r;

    for (i = r; i < pv->base.len; i++) {
        const void *other = sol_ptr_vector_get_no_check(pv, i);

        if (compare_cb(elem, other) != 0)
            break;

        if (elem == other)
            found_i = i;
    }

    if (found_i >= 0)
        return found_i;

    for (i = r; i > 0; i--) {
        const void *other = sol_ptr_vector_get_no_check(pv, i - 1);

        if (compare_cb(elem, other) != 0)
            break;

        if (elem == other)
            return i - 1;
    }

    return -ENODATA;
}

static inline int32_t
sol_ptr_vector_find_first_sorted(const struct sol_ptr_vector *pv, const void *elem, int (*compare_cb)(const void *data1, const void *data2))
{
    uint16_t i;
    int32_t r, found_i = -ENODATA;

    r = sol_ptr_vector_match_sorted(pv, elem, compare_cb);
    if (r < 0)
        return r;

    for (i = r;;) {
        const void *other = sol_ptr_vector_get_no_check(pv, i);

        if (compare_cb(elem, other) != 0)
            break;

        if (elem == other)
            found_i = i;

        if (i == 0)
            break;
        i--;
    }

    if (found_i >= 0)
        return found_i;

    for (i = r; i + 1 < pv->base.len; i++) {
        const void *other = sol_ptr_vector_get_no_check(pv, i + 1);

        if (compare_cb(elem, other) != 0)
            break;

        if (elem == other)
            return i + 1;
    }

    return -ENODATA;
}

#ifdef __cplusplus
}
#endif