xbyte_array.h

[詳解]

/*
 * License: MIT license
 * Copyright (c) <2016> <MaskedW [maskedw00@gmail.com]>
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy,
 * modify, merge, publish, distribute, sublicense, and/or sell copies
 * of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#ifndef picox_container_xbyte_array_h_
#define picox_container_xbyte_array_h_


#include <picox/core/xcore.h>


#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */


typedef struct
{
    uint8_t*    m_data;
    size_t      m_size;
    size_t      m_capacity;
    bool        m_is_heapdata;
} XByteArray;


static inline bool
xbarray_init(XByteArray* self, void* buffer, size_t size)
{
    X_ASSERT(self);

    memset(self, 0, sizeof(*self));
    if (! buffer)
    {
        buffer = (uint8_t*)x_malloc(size);
        if (! buffer)
            return false;
        self->m_is_heapdata = true;
    }
    self->m_data = buffer;
    self->m_capacity = size;

    return true;
}


static inline void
xbarray_deinit(XByteArray* self)
{
    X_ASSERT(self);
    if (self->m_is_heapdata)
    {
        x_free(self->m_data);
        self->m_is_heapdata = false;
    }
    self->m_data = NULL;
    self->m_size = 0;
    self->m_capacity = 0;
}


static inline const uint8_t*
xbarray_const_data(const XByteArray* self)
{
    X_ASSERT(self);
    return self->m_data;
}


static inline uint8_t*
xbarray_data(XByteArray* self)
{
    return (uint8_t*)xbarray_const_data(self);
}


static inline const uint8_t*
xbarray_const_at(const XByteArray* self, size_t index)
{
    X_ASSERT(self);
    X_ASSERT(self->m_size > index);
    return self->m_data + index;
}


static inline uint8_t*
xbarray_at(XByteArray* self, size_t index)
{
    return (uint8_t*)xbarray_const_at(self, index);
}


static inline size_t
xbarray_size(const XByteArray* self)
{
    X_ASSERT(self);
    return self->m_size;
}


static inline size_t
xbarray_capacity(const XByteArray* self)
{
    X_ASSERT(self);
    return self->m_capacity;
}


static inline bool
xbarray_empty(const XByteArray* self)
{
    X_ASSERT(self);
    return ! self->m_size;
}


static inline bool
xbarray_full(const XByteArray* self)
{
    X_ASSERT(self);
    return self->m_size == self->m_capacity;
}


static inline size_t
xbarray_space(const XByteArray* self)
{
    X_ASSERT(self);
    return self->m_capacity - self->m_size;
}


static inline void
xbarray_clear(XByteArray* self)
{
    X_ASSERT(self);
    self->m_size = 0;
}


static inline void
xbarray_fill(XByteArray* self, uint8_t value)
{
    X_ASSERT(self);
    memset(self->m_data, value, self->m_size);
}


static inline bool
xbarray_reserve(XByteArray* self, size_t size)
{
    X_ASSERT(self);
    if (self->m_capacity >= size)
        return true;

    if (! self->m_is_heapdata)
        return false;

    uint8_t* const buf = (uint8_t*)x_realloc2(self->m_data,
                                              self->m_size,
                                              size);
    if (! buf)
        return false;

    self->m_data = buf;
    self->m_capacity = size;

    return true;
}


static inline bool
xbarray_make_space_if(XByteArray* self, size_t size)
{
    const size_t space = self->m_capacity - self->m_size;
    if (space >= size)
        return true;

    const size_t new_capcity = size > space + self->m_capacity ?
                               size :
                               self->m_capacity * 2;
    return xbarray_reserve(self, new_capcity);
}


static inline void
xbarray_strict_make_space_if(XByteArray* self, size_t size)
{
    const bool ok = xbarray_make_space_if(self, size);
    X_ASSERT(ok);
    X_UNUSED(ok);
}


static inline void
xbarray_push_back_n(XByteArray* self, const void* src, size_t size)
{
    X_ASSERT(self);
    X_ASSERT(src);

    xbarray_strict_make_space_if(self, size);
    memcpy(self->m_data + self->m_size, src, size);
    self->m_size += size;
}


static inline void
xbarray_push_back(XByteArray* self, uint8_t value)
{
    X_ASSERT(self);

    xbarray_strict_make_space_if(self, sizeof(value));
    *(self->m_data + self->m_size) = value;
    self->m_size += 1;
}


static inline void
xbarray_pop_back_n(XByteArray* self, void* dst, size_t size)
{
    X_ASSERT(self);
    X_ASSERT(dst);
    X_ASSERT(self->m_size >= size);

    self->m_size -= size;
    if (dst)
        memcpy(dst, self->m_data + self->m_size, size);
}


static inline uint8_t
xbarray_pop_back(XByteArray* self)
{
    X_ASSERT(self);
    self->m_size -= 1;
    const uint8_t value = *(self->m_data + self->m_size);

    return value;
}


static inline bool
xbarray_shrink_to_fit(XByteArray* self)
{
    X_ASSERT(self);

    uint8_t* const buf = (uint8_t*)x_realloc2(self->m_data,
                                              self->m_capacity,
                                              self->m_size);
    if (! buf)
        return false;

    self->m_data = buf;
    self->m_capacity = self->m_size;

    return true;
}


static inline void
xbarray_insert_n(XByteArray* self, size_t index, const void* src, size_t size)
{
    X_ASSERT(self);

    if (index == self->m_size)
    {
        xbarray_push_back_n(self, src, size);
        return;
    }

    X_ASSERT(src);
    X_ASSERT(index <= self->m_size);

    xbarray_strict_make_space_if(self, size);
    memmove(self->m_data + index + size,
            self->m_data + index,
            self->m_size - index);
    memcpy(self->m_data + index, src, size);
    self->m_size += size;
}


static inline void
xbarray_insert(XByteArray* self, size_t index, uint8_t value)
{
    xbarray_insert_n(self, index, &value, sizeof(value));
}


static inline void
xbarray_erase_n(XByteArray* self, size_t index, size_t size)
{
    X_ASSERT(self);
    X_ASSERT(index <= self->m_size);

    memmove(self->m_data + index,
            self->m_data + index + size,
            self->m_size - (index + size));
    self->m_size -= size;
}


static inline void
xbarray_erase(XByteArray* self, size_t index)
{
    xbarray_erase_n(self, index, sizeof(uint8_t));
}


#ifdef __cplusplus
}
#endif /* __cplusplus */


#endif /* picox_container_xbyte_array_h_ */