willemt/bipbuffer

A circular buffer alternative written in C under a BSD license

bipbuffer's Issues

Missing `package.json' for clibs

I noticed you're listed here but missing a package.json

Unecessary check

You don't need this check, you can just do that unconditionally and it'll work in both cases.

bipbuffer/bipbuffer.c

Line 125 in cb7b9ad

if (1 == me->b_inuse)

Please add attribution

Neat and tidy implementation and i'll be using it in C ( thats how i found it , through searching for Bip in C )
But please add attribution somewhere as per
http://accidentalscientist.com/2010/02/the-darker-side-of-google-open-source-taking-without-attribution.html

how

if I have a buff like below:

**12
^
|
A
Region B is not used.
Now, if I want to offer more than 2 bytes for example 4 bytes "3456", the bipbuf_offer will return 0.
But there are enough buffer for 4bytes, it can offer region B and the result will like below:

345612**
^ ^
| |
B A

bipbuf_offer can not work correct

if I have a buff like below:

****12**
    ^
    |
    A

Region B is not used.
Now, if I want to offer more than 2 bytes for example 4 bytes "3456", the bipbuf_offer will return 0.
But there are enough buffer for 4bytes, it can offer region B and the result will like below:

345612**
^   ^
|   |
B   A

RFC bipbup_offer() : try to fit after A before activating B

Here's a different implementation of bipbup_offer() :

• if B is in use, append data there (no change)
• if B is unused, and there is enough space after A, append data there
• fallback : activate B area and write data there, if possible.

Advantage is slightly increased efficiency, at basically 0 cost.

Note : currently untested

*****
int bipbuf_offer(bipbuf_t* me, const unsigned char *data, const int size)
{
    if (1 == me->b_inuse)
    {
	/* check available space between region B and region A */
        if ((me->a_start - me->b_end) < size) return 0;

        memcpy(me->data + me->b_end, data, size);
        me->b_end += size;
	return size;
    }

    /* no B area (yet). Check if we can fit in the remaining space */
    if (size < (me->size - me->a_end))
    {
        memcpy(me->data + me->a_end, data, size);
        me->a_end += size;
	return size;
    }

    /* didn't fit, activate B if possible */
    if (size > (me->a_start))
    {
	/* won't fit */
	return 0;
    }

    me->b_inuse = 1;
    memcpy(me->data, data, size);
    me->b_end += size;
    return size;
}