buffer: Rename fields again

I even confused myself here because length is actually not the length of
the buffer that I wanted. It is what has been allocated. That is however
nothing that we need to access at any time. Therefore the fields have
been renamed to be a little bit more intuitive again.

Signed-off-by: Michael Tremer <michael.tremer@ipfire.org>

diff --git a/src/pakfire/buffer.c b/src/pakfire/buffer.c
index 7f32dcb3e9cc594b03ab392ff3bfc8f3f26ac32c..c70f60ebba1c0ef357a71e84a5d5bcf8766ef71e 100644 (file)
--- a/src/pakfire/buffer.c
+++ b/src/pakfire/buffer.c
@@ -35,11 +35,11 @@ void pakfire_buffer_set_max_length(struct pakfire_buffer* self, size_t max_lengt
 }
 
 size_t pakfire_buffer_length(struct pakfire_buffer* self) {
-       return self->used;
+       return self->length;
 }
 
 int pakfire_buffer_is_empty(struct pakfire_buffer* self) {
-       return (self->used == 0);
+       return (self->length == 0);
 }
 
 int pakfire_buffer_is_full(struct pakfire_buffer* self) {
@@ -47,11 +47,11 @@ int pakfire_buffer_is_full(struct pakfire_buffer* self) {
        if (!self->max_length)
                return 0;
 
-       return (self->used >= self->max_length);
+       return (self->length >= self->max_length);
 }
 
 void pakfire_buffer_clear(struct pakfire_buffer* buffer) {
-       buffer->used = 0;
+       buffer->length = 0;
 }
 
 void pakfire_buffer_free(struct pakfire_buffer* buffer) {
@@ -83,7 +83,7 @@ static int pakfire_buffer_resize(struct pakfire_buffer* self, size_t length) {
                return -ENOBUFS;
 
        // Don't make the buffer smaller than the used space
-       if (length < self->used)
+       if (length < self->length)
                return -EINVAL;
 
        // Round up to the nearest chunk size
@@ -95,7 +95,7 @@ static int pakfire_buffer_resize(struct pakfire_buffer* self, size_t length) {
                return -errno;
 
        // Adjust the size
-       self->length = length;
+       self->__allocated = length;
 
        return 0;
 }
@@ -103,19 +103,19 @@ static int pakfire_buffer_resize(struct pakfire_buffer* self, size_t length) {
 // Grows the buffer
 static int pakfire_buffer_grow(struct pakfire_buffer* self, size_t length) {
        // Check if we actually need to grow
-       if (self->length >= self->used + length)
+       if (self->__allocated >= self->length + length)
                return 0;
 
-       return pakfire_buffer_resize(self, self->used + length);
+       return pakfire_buffer_resize(self, self->length + length);
 }
 
 // Shrinks the buffer to its minimum size
 static int pakfire_buffer_shrink(struct pakfire_buffer* self) {
        // Shrink whenever we hit the wastage level
-       if (self->length - self->used < MAX_WASTAGE)
+       if (self->__allocated - self->length < MAX_WASTAGE)
                return 0;
 
-       return pakfire_buffer_resize(self, self->used);
+       return pakfire_buffer_resize(self, self->length);
 }
 
 int pakfire_buffer_push(struct pakfire_buffer* self, const char* data, size_t length) {
@@ -135,19 +135,19 @@ int pakfire_buffer_push(struct pakfire_buffer* self, const char* data, size_t le
                return r;
 
        // Copy the data
-       memcpy(self->data + self->used, data, length);
-       self->used += length;
+       memcpy(self->data + self->length, data, length);
+       self->length += length;
 
        return length;
 }
 
 int pakfire_buffer_pop(struct pakfire_buffer* self, size_t length) {
        // Check if we actually have enough data
-       if (self->used < length)
+       if (self->length < length)
                return -EINVAL;
 
-       memmove(self->data, self->data + length, self->used - length);
-       self->used -= length;
+       memmove(self->data, self->data + length, self->length - length);
+       self->length -= length;
 
        // Shrink the buffer if we need to
        return pakfire_buffer_shrink(self);
@@ -166,7 +166,7 @@ int pakfire_buffer_read(struct pakfire_buffer* self, int fd) {
                        return r;
 
                // Read into the buffer
-               bytes_read = read(fd, self->data + self->used, self->length - self->used);
+               bytes_read = read(fd, self->data + self->length, self->__allocated - self->length);
                if (bytes_read < 0)
                        return -errno;
 
@@ -174,10 +174,10 @@ int pakfire_buffer_read(struct pakfire_buffer* self, int fd) {
                total_bytes_read += bytes_read;
 
                // We now use more space
-               self->used += bytes_read;
+               self->length += bytes_read;
 
                // If we have not filled the entire space, we have read everything for now
-               if (self->used < self->length)
+               if (self->length < self->__allocated)
                        break;
        }
 
@@ -189,11 +189,11 @@ int pakfire_buffer_write(struct pakfire_buffer* self, int fd) {
        int r;
 
        // Do nothing if the buffer is empty
-       if (!self->used)
+       if (!self->length)
                return 0;
 
        // Write as much data as possible
-       bytes_written = write(fd, self->data, self->used);
+       bytes_written = write(fd, self->data, self->length);
        if (bytes_written < 0)
                return -errno;
 
@@ -224,12 +224,12 @@ int pakfire_buffer_fill(struct pakfire_buffer* self,
                return r;
 
        // Call the callback
-       bytes_written = callback(ctx, data, self->data + self->used, self->length - self->used);
+       bytes_written = callback(ctx, data, self->data + self->length, self->__allocated - self->length);
        if (bytes_written < 0)
                return bytes_written;
 
        // Update the used space
-       self->used += bytes_written;
+       self->length += bytes_written;
 
        return bytes_written;
 }
@@ -238,11 +238,11 @@ size_t pakfire_buffer_find_line(struct pakfire_buffer* self) {
        char* p = NULL;
 
        // Nothing to do if there is no data
-       if (!self->used)
+       if (!self->length)
                return 0;
 
        // Find the byte
-       p = memchr(self->data, '\n', self->used);
+       p = memchr(self->data, '\n', self->length);
        if (!p)
                return 0;
 

diff --git a/src/pakfire/buffer.h b/src/pakfire/buffer.h
index b1f5473918802f3fa19b5fbdcc3064af22a77f7f..5ab14bb89c992ff7358b7e292cdc6a7d6a6e58f4 100644 (file)
--- a/src/pakfire/buffer.h
+++ b/src/pakfire/buffer.h
@@ -28,10 +28,12 @@ typedef ssize_t (*pakfire_buffer_input_callback)
 
 struct pakfire_buffer {
        char* data;
-       size_t length;
+
+       // Store how large the allocated buffer is
+       size_t __allocated;
 
        // Actually used data
-       size_t used;
+       size_t length;
 
        // Defines the maximum length this buffer can grow to
        size_t max_length;