xmessage_buffer.h

[詳解]

/*
 * License: MIT license
 * Copyright (c) <2015> <MaskedW [maskedw00@gmail.com]>
 *
 * Permission is hereby granted, free of uint8_tge, to any person
 * obtaining a copy of self 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 self 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_xmessage_buffer_h_
#define picox_container_xmessage_buffer_h_


#include <picox/core/xcore.h>


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


typedef union XMessageHeader
{
    size_t  size;
    uint8_t bytes[sizeof(size_t)];
} XMessageHeader;


typedef struct XMessageBuffer
{
    uint8_t*    data;       
    size_t      first;      
    size_t      last;       
    size_t      size;       
    size_t      capacity;   
} XMessageBuffer;


static inline void
xmsgbuf_init(XMessageBuffer* self, void* buffer, size_t size)
{
    X_ASSERT(self);
    X_ASSERT(buffer);
    X_ASSERT(size > sizeof(XMessageHeader));

    self->data = buffer;
    self->first = self->last = self->size = 0;
    self->capacity = size;
}


static inline uint8_t*
xmsgbuf_data(const XMessageBuffer* self)
{
    X_ASSERT(self);
    return self->data;
}


static inline void
xmsgbuf_clear(XMessageBuffer* self)
{
    X_ASSERT(self);
    self->first = self->last = self->size = 0;
}


static inline size_t
xmsgbuf_size(const XMessageBuffer* self)
{
    X_ASSERT(self);
    return self->size;
}


static inline bool
xmsgbuf_empty(const XMessageBuffer* self)
{
    X_ASSERT(self);
    return self->size == 0;
}


static inline size_t
xmsgbuf_capacity(const XMessageBuffer* self)
{
    X_ASSERT(self);
    return self->capacity;
}


static inline size_t
xmsgbuf_reserve(const XMessageBuffer* self)
{
    X_ASSERT(self);
    return self->capacity - self->size;
}


static inline bool
xmsgbuf_full(const XMessageBuffer* self)
{
    X_ASSERT(self);
    return xmsgbuf_reserve(self) <= sizeof(XMessageHeader);
}


static inline size_t
xmsgbuf_msg_size(const XMessageBuffer* self)
{
    X_ASSERT(self);
    if (xmsgbuf_empty(self))
        return 0;

    XMessageHeader header;
    size_t rpos = self->first;
    int i;
    for (i = 0; i < (int)sizeof(XMessageHeader); i++)
    {
        header.bytes[i] = self->data[rpos++];
        if (rpos == self->capacity)
            rpos = 0;
    }

    return header.size;
}


static inline size_t
xmsgbuf_num(const XMessageBuffer* self)
{
    X_ASSERT(self);

    size_t n = 0;
    XMessageHeader hdr;
    size_t first = self->first;
    size_t size = self->size;
    int i;

    while (size)
    {
        for (i = 0; i < (int)sizeof(XMessageHeader); i++)
        {
            hdr.bytes[i] = self->data[first++];
            if (first == self->capacity)
                first = 0;
        }
        size -= (sizeof(XMessageHeader) + hdr.size);
        first = (first + hdr.size) % self->capacity;
        n++;
    }

    return n;
}


static inline void
xmsgbuf_skip(XMessageBuffer* self)
{
    X_ASSERT(self);

    if (xmsgbuf_empty(self))
        return;

    XMessageHeader hdr;
    size_t first = self->first;
    int i;

    for (i = 0; i < (int)sizeof(XMessageHeader); i++)
    {
        hdr.bytes[i] = self->data[first++];
        if (first == self->capacity)
            first = 0;
    }
    first = (first + hdr.size) % self->capacity;
    self->size -= sizeof(XMessageHeader) + hdr.size;
    self->first = first;
}


static inline void
xmsgbuf_push(XMessageBuffer* self, const void* src, size_t size)
{
    X_ASSERT(self);
    X_ASSERT(src);
    X_ASSERT(size > 0);
    X_ASSERT(xmsgbuf_reserve(self) >= size + sizeof(XMessageHeader));


    XMessageHeader header;
    header.size = size;
    self->size += sizeof(XMessageHeader) + size;

    size_t pos = self->last;
    int i;
    for (i = 0; i < (int)sizeof(XMessageHeader); i++)
    {
        self->data[pos++] = header.bytes[i];
        if (pos >= self->capacity)
            pos = 0;
    }

    const uint8_t* from = src;
    uint8_t* to;

    if (pos + size > self->capacity)
    {
        const size_t until_tail = self->capacity - pos;
        to = self->data + pos;
        memcpy(to, from, until_tail);

        size -= until_tail;
        from += until_tail;
        pos  = 0;
    }

    to = self->data + pos;
    memcpy(to, from, size);

    pos += size;
    if (pos == self->capacity)
        pos = 0;
    self->last = pos;
}


static inline size_t
xmsgbuf_pull(XMessageBuffer* self, void* dst)
{
    X_ASSERT(self);
    X_ASSERT(dst);

    if (xmsgbuf_empty(self))
        return 0;

    XMessageHeader header;
    size_t pos = self->first;
    int i;
    for (i = 0; i < (int)sizeof(XMessageHeader); i++) {
        header.bytes[i] = self->data[pos++];
        if (pos == self->capacity)
            pos = 0;
    }

    uint8_t* to = dst;
    const uint8_t* from;
    size_t to_read = header.size;

    if (pos + to_read > self->capacity)
    {
        const size_t until_tail = self->capacity - pos;
        from = self->data + pos;
        memcpy(to, from, until_tail);
        to_read -= until_tail;
        to      += until_tail;
        pos     = 0;
    }

    from = self->data + pos;
    memcpy(to, from, to_read);

    pos += to_read;
    if (pos == self->capacity)
        pos = 0;
    self->first = pos;
    self->size -= header.size + sizeof(XMessageHeader);

    return header.size;
}


#ifdef __cplusplus
}
#endif // __cplusplus


#endif // picox_container_xmessage_buffer_h_