sol-buffer.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 <assert.h>

#include <errno.h>
#include <sol-str-slice.h>
#include <sol-types.h>
#include <stdarg.h>

#ifdef __cplusplus
extern "C" {
#endif

#ifdef __cplusplus
#define SOL_BUFFER_C_CAST
#else
#define SOL_BUFFER_C_CAST (struct sol_buffer)
#endif

enum sol_buffer_flags {
    SOL_BUFFER_FLAGS_DEFAULT = 0,
    SOL_BUFFER_FLAGS_FIXED_CAPACITY = (1 << 0),
    SOL_BUFFER_FLAGS_NO_FREE = (1 << 1),
    SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED = (SOL_BUFFER_FLAGS_FIXED_CAPACITY | SOL_BUFFER_FLAGS_NO_FREE),
    SOL_BUFFER_FLAGS_NO_NUL_BYTE = (1 << 2),
    SOL_BUFFER_FLAGS_CLEAR_MEMORY = (1 << 3),
};

#define SOL_BUFFER_NEEDS_NUL_BYTE(buf) (!((buf)->flags & SOL_BUFFER_FLAGS_NO_NUL_BYTE))

#define SOL_BUFFER_CAN_RESIZE(buf) \
    (!(buf->flags & (SOL_BUFFER_FLAGS_FIXED_CAPACITY | SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED)))

typedef struct sol_buffer {
    void *data; 
    size_t capacity; 
    size_t used;  
    enum sol_buffer_flags flags; 
} sol_buffer;

enum sol_decode_case {
    SOL_DECODE_UPPERCASE,
    SOL_DECODE_LOWERCASE,
    SOL_DECODE_BOTH
};

#define SOL_BUFFER_INIT_EMPTY SOL_BUFFER_C_CAST { .data = NULL, .capacity = 0, .used = 0, .flags = SOL_BUFFER_FLAGS_DEFAULT }

#define SOL_BUFFER_INIT_FLAGS(data_, size_, flags_) SOL_BUFFER_C_CAST { .data = data_, .capacity = size_, .used = 0, .flags = (enum sol_buffer_flags)(flags_) }

#define SOL_BUFFER_INIT_CONST(data_, size_) SOL_BUFFER_C_CAST { .data = data_, .capacity = size_, .used = size_, .flags = SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED }

#define SOL_BUFFER_INIT_DATA(data_, size_) SOL_BUFFER_C_CAST { .data = data_, .capacity = size_, .used = size_, .flags = SOL_BUFFER_FLAGS_DEFAULT }

#define SOL_BUFFER_DECLARE_STATIC(name_, size_) \
    uint8_t name_ ## storage[(size_)] = { 0 }; \
    struct sol_buffer name_ = SOL_BUFFER_INIT_FLAGS(name_ ## storage, (size_), SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED)

static inline void
sol_buffer_init(struct sol_buffer *buf)
{
    assert(buf);
    buf->data = NULL;
    buf->capacity = 0;
    buf->used = 0;
    buf->flags = SOL_BUFFER_FLAGS_DEFAULT;
}

static inline void
sol_buffer_init_flags(struct sol_buffer *buf, void *data, size_t data_size, enum sol_buffer_flags flags)
{
    assert(buf);
    assert((flags & SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED) ? !!data : 1);
    buf->data = data;
    buf->capacity = data_size;
    buf->used = 0;
    buf->flags = flags;
}

void sol_buffer_fini(struct sol_buffer *buf);

static inline void *
sol_buffer_at(const struct sol_buffer *buf, size_t pos)
{
    if (!buf)
        return NULL;
    if (pos > buf->used)
        return NULL;
    return (char *)buf->data + pos;
}

static inline void *
sol_buffer_at_end(const struct sol_buffer *buf)
{
    if (!buf)
        return NULL;
    return (char *)buf->data + buf->used;
}

int sol_buffer_resize(struct sol_buffer *buf, size_t new_size);

int sol_buffer_expand(struct sol_buffer *buf, size_t bytes);

int sol_buffer_ensure(struct sol_buffer *buf, size_t min_size);

int sol_buffer_set_slice(struct sol_buffer *buf, const struct sol_str_slice slice);

static inline struct sol_str_slice
sol_buffer_get_slice(const struct sol_buffer *buf)
{
    if (!buf)
        return SOL_STR_SLICE_STR(NULL, 0);
    return SOL_STR_SLICE_STR((char *)buf->data, buf->used);
}

static inline int
sol_buffer_set_buffer(struct sol_buffer *dst, const struct sol_buffer *src)
{
    if (!dst || !src)
        return -EINVAL;

    return sol_buffer_set_slice(dst, sol_buffer_get_slice(src));
}

static inline struct sol_str_slice
sol_buffer_get_slice_at(const struct sol_buffer *buf, size_t pos)
{
    if (!buf || buf->used < pos)
        return SOL_STR_SLICE_STR(NULL, 0);
    return SOL_STR_SLICE_STR((char *)sol_buffer_at(buf,  pos), buf->used - pos);
}

int sol_buffer_insert_char(struct sol_buffer *buf, size_t pos, const char c);

int sol_buffer_append_char(struct sol_buffer *buf, const char c);

int sol_buffer_append_slice(struct sol_buffer *buf, const struct sol_str_slice slice);

int sol_buffer_append_bytes(struct sol_buffer *buf, const uint8_t *bytes, size_t size);

int sol_buffer_append_buffer(struct sol_buffer *dst, const struct sol_buffer *src);

int sol_buffer_set_slice_at(struct sol_buffer *buf, size_t pos, const struct sol_str_slice slice);

static inline int
sol_buffer_set_buffer_at(struct sol_buffer *dst, size_t pos, const struct sol_buffer *src)
{
    if (!dst || !src)
        return -EINVAL;

    return sol_buffer_set_slice_at(dst, pos, sol_buffer_get_slice(src));
}

int sol_buffer_set_char_at(struct sol_buffer *buf, size_t pos, char c);

int sol_buffer_insert_bytes(struct sol_buffer *buf, size_t pos, const uint8_t *bytes, size_t size);

int sol_buffer_insert_slice(struct sol_buffer *buf, size_t pos, const struct sol_str_slice slice);

static inline int
sol_buffer_insert_buffer(struct sol_buffer *dst, size_t pos, const struct sol_buffer *src)
{
    if (!dst || !src)
        return -EINVAL;

    return sol_buffer_insert_slice(dst, pos, sol_buffer_get_slice(src));
}

// TODO: move this to some other file? where
extern const char SOL_BASE64_MAP[66];

int sol_buffer_insert_as_base64(struct sol_buffer *buf, size_t pos, const struct sol_str_slice slice, const char base64_map[SOL_STATIC_ARRAY_SIZE(65)]);

int sol_buffer_append_as_base64(struct sol_buffer *buf, const struct sol_str_slice slice, const char base64_map[SOL_STATIC_ARRAY_SIZE(65)]);

int sol_buffer_insert_from_base64(struct sol_buffer *buf, size_t pos, const struct sol_str_slice slice, const char base64_map[SOL_STATIC_ARRAY_SIZE(65)]);

int sol_buffer_append_from_base64(struct sol_buffer *buf, const struct sol_str_slice slice, const char base64_map[SOL_STATIC_ARRAY_SIZE(65)]);

int sol_buffer_insert_as_base16(struct sol_buffer *buf, size_t pos, const struct sol_str_slice slice, bool uppercase);

int sol_buffer_append_as_base16(struct sol_buffer *buf, const struct sol_str_slice slice, bool uppercase);

int sol_buffer_insert_from_base16(struct sol_buffer *buf, size_t pos, const struct sol_str_slice slice, enum sol_decode_case decode_case);

int sol_buffer_append_from_base16(struct sol_buffer *buf, const struct sol_str_slice slice, enum sol_decode_case decode_case);

int sol_buffer_append_vprintf(struct sol_buffer *buf, const char *fmt, va_list args) SOL_ATTR_PRINTF(2, 0);

static inline int sol_buffer_append_printf(struct sol_buffer *buf, const char *fmt, ...) SOL_ATTR_PRINTF(2, 3);
static inline int
sol_buffer_append_printf(struct sol_buffer *buf, const char *fmt, ...)
{
    va_list args;
    int r;

    va_start(args, fmt);
    r = sol_buffer_append_vprintf(buf, fmt, args);
    va_end(args);
    return r;
}

int sol_buffer_insert_vprintf(struct sol_buffer *buf, size_t pos, const char *fmt, va_list args) SOL_ATTR_PRINTF(3, 0);

static inline int sol_buffer_insert_printf(struct sol_buffer *buf, size_t pos, const char *fmt, ...) SOL_ATTR_PRINTF(3, 4);
static inline int
sol_buffer_insert_printf(struct sol_buffer *buf, size_t pos, const char *fmt, ...)
{
    va_list args;
    int r;

    va_start(args, fmt);
    r = sol_buffer_insert_vprintf(buf, pos, fmt, args);
    va_end(args);
    return r;
}

static inline int
sol_buffer_trim(struct sol_buffer *buf)
{
    size_t new_size;

    if (!buf)
        return -EINVAL;

    if (buf->flags & SOL_BUFFER_FLAGS_NO_NUL_BYTE)
        new_size = buf->used;
    else if (buf->used == SIZE_MAX)
        return -EOVERFLOW;
    else
        new_size = buf->used + 1;

    if (new_size == buf->capacity)
        return 0;

    return sol_buffer_resize(buf, new_size);
}

void *sol_buffer_steal(struct sol_buffer *buf, size_t *size);

void *sol_buffer_steal_or_copy(struct sol_buffer *buf, size_t *size);

struct sol_buffer *sol_buffer_copy(const struct sol_buffer *buf);

static inline void
sol_buffer_reset(struct sol_buffer *buf)
{
    buf->used = 0;
}

static inline struct sol_buffer *
sol_buffer_new(void)
{
    struct sol_buffer *buf = (struct sol_buffer *)calloc(1, sizeof(struct sol_buffer));

    if (!buf) return NULL;

    sol_buffer_init(buf);

    return buf;
}

static inline void
sol_buffer_free(struct sol_buffer *buf)
{
    sol_buffer_fini(buf);
    free(buf);
}

int sol_buffer_ensure_nul_byte(struct sol_buffer *buf);


int sol_buffer_remove_data(struct sol_buffer *buf, size_t offset, size_t size);


struct sol_blob *sol_buffer_to_blob(struct sol_buffer *buf);

#ifdef __cplusplus
}
#endif