Reformatted according to clang-format rules

Author: codepr

include/timeseries.h

@@ -10,9 +10,9 @@
 #include <time.h>
 
 #define TS_NAME_MAX_LENGTH 1 << 9
-#define TS_CHUNK_SIZE 900 // 15 min
-#define TS_MAX_PARTITIONS 16
-#define DATA_PATH_SIZE 1 << 8
+#define TS_CHUNK_SIZE      900 // 15 min
+#define TS_MAX_PARTITIONS  16
+#define DATA_PATH_SIZE     1 << 8
 
 extern const size_t TS_FLUSH_SIZE;
 extern const size_t TS_BATCH_OFFSET;

src/arena.c

@@ -1,15 +1,16 @@
 #include "arena.h"
 
-#define DEFAULT_ALIGNMENT (2 * sizeof(void *))
+#define DEFAULT_ALIGNMENT  (2 * sizeof(void *))
 #define is_power_of_two(x) ((x != 0) && ((x & (x - 1)) == 0))
 
-static uintptr_t align_forward(uintptr_t ptr, size_t alignment) {
+static uintptr_t align_forward(uintptr_t ptr, size_t alignment)
+{
     uintptr_t p, a, modulo;
     if (!is_power_of_two(alignment))
         return 0;
 
-    p = ptr;
-    a = (uintptr_t)alignment;
+    p      = ptr;
+    a      = (uintptr_t)alignment;
     modulo = p & (a - 1);
 
     if (modulo)
@@ -18,9 +19,10 @@ static uintptr_t align_forward(uintptr_t ptr, size_t alignment) {
     return p;
 }
 
-static void *arena_alloc_aligned(Arena *a, size_t size, size_t alignment) {
+static void *arena_alloc_aligned(Arena *a, size_t size, size_t alignment)
+{
     uintptr_t curr_ptr = (uintptr_t)a->base + (uintptr_t)a->offset;
-    uintptr_t offset = align_forward(curr_ptr, alignment);
+    uintptr_t offset   = align_forward(curr_ptr, alignment);
     offset -= (uintptr_t)a->base;
 
     if (offset + size > a->size)
@@ -33,25 +35,29 @@ static void *arena_alloc_aligned(Arena *a, size_t size, size_t alignment) {
     return ptr;
 }
 
-void *arena_alloc(size_t size, void *context) {
+void *arena_alloc(size_t size, void *context)
+{
     if (!size)
         return 0;
 
     return arena_alloc_aligned((Arena *)context, size, DEFAULT_ALIGNMENT);
 }
 
-void arena_free(size_t size, void *ptr, void *context) {
+void arena_free(size_t size, void *ptr, void *context)
+{
     (void)ptr;
     (void)size;
     (void)context;
 }
 
-void arena_free_all(void *context) {
-    Arena *a = context;
-    a->offset = 0;
+void arena_free_all(void *context)
+{
+    Arena *a     = context;
+    a->offset    = 0;
     a->committed = 0;
 }
 
-Arena arena_init(void *buffer, size_t size) {
+Arena arena_init(void *buffer, size_t size)
+{
     return (Arena){.base = buffer, .size = size};
 }

src/arena.h

@@ -10,7 +10,7 @@ typedef struct allocator {
     void *context;
 } Allocator;
 
-#define alloc(T, n, a) ((T *)((a).alloc(sizeof(T) * n, (a).context)))
+#define alloc(T, n, a)   ((T *)((a).alloc(sizeof(T) * n, (a).context)))
 #define release(s, p, a) ((a).free(s, p, (a).context))
 
 typedef struct arena {

src/binary.c

@@ -8,22 +8,25 @@ uint8_t read_u8(const uint8_t *const buf) { return ((uint8_t)*buf); }
 /*
  * write_u16() -- store a 16-bit int into a char buffer (like htons())
  */
-void write_u16(uint8_t *buf, uint16_t val) {
+void write_u16(uint8_t *buf, uint16_t val)
+{
     *buf++ = val >> 8;
     *buf++ = val;
 }
 
 /*
  * read_u16() -- unpack a 16-bit unsigned from a char buffer (like ntohs())
  */
-uint16_t read_u16(const uint8_t *const buf) {
+uint16_t read_u16(const uint8_t *const buf)
+{
     return ((uint16_t)buf[0] << 8) | buf[1];
 }
 
 /*
  * write_u32() -- store a 32-bit int into a char buffer (like htonl())
  */
-void write_u32(uint8_t *buf, uint32_t val) {
+void write_u32(uint8_t *buf, uint32_t val)
+{
     *buf++ = val >> 24;
     *buf++ = val >> 16;
     *buf++ = val >> 8;
@@ -33,15 +36,17 @@ void write_u32(uint8_t *buf, uint32_t val) {
 /*
  * read_u32() -- unpack a 32-bit unsigned from a char buffer (like ntohl())
  */
-uint32_t read_u32(const uint8_t *const buf) {
+uint32_t read_u32(const uint8_t *const buf)
+{
     return ((uint32_t)buf[0] << 24) | ((uint32_t)buf[1] << 16) |
            ((uint32_t)buf[2] << 8) | buf[3];
 }
 
 /*
  * write_i64() -- store a 64-bit int into a char buffer (like htonl())
  */
-void write_i64(uint8_t *buf, uint64_t val) {
+void write_i64(uint8_t *buf, uint64_t val)
+{
     *buf++ = val >> 56;
     *buf++ = val >> 48;
     *buf++ = val >> 40;
@@ -55,7 +60,8 @@ void write_i64(uint8_t *buf, uint64_t val) {
 /*
  * read_i64() -- unpack a 64-bit unsigned from a char buffer (like ntohl())
  */
-uint64_t read_i64(const uint8_t *const buf) {
+uint64_t read_i64(const uint8_t *const buf)
+{
     return ((uint64_t)buf[0] << 56) | ((uint64_t)buf[1] << 48) |
            ((uint64_t)buf[2] << 40) | ((uint64_t)buf[3] << 32) |
            ((uint64_t)buf[4] << 24) | ((uint64_t)buf[5] << 16) |
@@ -66,7 +72,8 @@ uint64_t read_i64(const uint8_t *const buf) {
  * write_f64() -- store a 64-bit float into a char buffer, taken from beej.us
  * guide
  */
-void write_f64(uint8_t *buf, double_t val) {
+void write_f64(uint8_t *buf, double_t val)
+{
     unsigned bits = 64, expbits = 11;
     long double fnorm;
     int shift;
@@ -78,10 +85,10 @@ void write_f64(uint8_t *buf, double_t val) {
     } else {
         // check sign and begin normalization
         if (val < 0) {
-            sign = 1;
+            sign  = 1;
             fnorm = -val;
         } else {
-            sign = 0;
+            sign  = 0;
             fnorm = val;
         }
 
@@ -95,13 +102,13 @@ void write_f64(uint8_t *buf, double_t val) {
             fnorm *= 2.0;
             shift--;
         }
-        fnorm = fnorm - 1.0;
+        fnorm       = fnorm - 1.0;
 
         // calculate the binary form (non-float) of the significand data
         significand = fnorm * ((1LL << significandbits) + 0.5f);
 
         // get the biased exponent
-        exp = shift + ((1 << (expbits - 1)) - 1); // shift + bias
+        exp         = shift + ((1 << (expbits - 1)) - 1); // shift + bias
 
         // return the final answer
         uint64_t d =
@@ -115,8 +122,9 @@ void write_f64(uint8_t *buf, double_t val) {
  * read_f64() -- unpack a 64-bit float into a char buffer, taken from beej.us
  * guide
  */
-double_t read_f64(const uint8_t *const buf) {
-    uint64_t i = read_i64(buf);
+double_t read_f64(const uint8_t *const buf)
+{
+    uint64_t i    = read_i64(buf);
     unsigned bits = 64, expbits = 11;
     long double result;
     long long shift;
@@ -132,7 +140,7 @@ double_t read_f64(const uint8_t *const buf) {
     result += 1.0f;                                // add the one back on
 
     // deal with the exponent
-    bias = (1 << (expbits - 1)) - 1;
+    bias  = (1 << (expbits - 1)) - 1;
     shift = ((i >> significandbits) & ((1LL << expbits) - 1)) - bias;
     while (shift > 0) {
         result *= 2.0;

src/client.c

@@ -14,7 +14,8 @@
  * Create a non-blocking socket and use it to connect to the specified host and
  * port
  */
-static int roach_connect(const struct connect_options *opts) {
+static int roach_connect(const struct connect_options *opts)
+{
 
     /* socket: create the socket */
     int fd = socket(opts->s_family, SOCK_STREAM, 0);
@@ -24,7 +25,7 @@ static int roach_connect(const struct connect_options *opts) {
     /* Set socket timeout for read and write if present on options */
     if (opts->timeout > 0) {
         struct timeval tv;
-        tv.tv_sec = opts->timeout;
+        tv.tv_sec  = opts->timeout;
         tv.tv_usec = 0;
         setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (const char *)&tv, sizeof(tv));
         setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, (const char *)&tv, sizeof(tv));
@@ -41,8 +42,8 @@ static int roach_connect(const struct connect_options *opts) {
 
         /* build the server's address */
         addr.sin_family = opts->s_family;
-        addr.sin_port = htons(opts->s_port);
-        addr.sin_addr = *((struct in_addr *)server->h_addr);
+        addr.sin_port   = htons(opts->s_port);
+        addr.sin_addr   = *((struct in_addr *)server->h_addr);
         bzero(&(addr.sin_zero), 8);
 
         /* connect: create a connection with the server */
@@ -76,11 +77,13 @@ static int roach_connect(const struct connect_options *opts) {
     return CLIENT_FAILURE;
 }
 
-void client_init(Client *c, const struct connect_options *opts) {
+void client_init(Client *c, const struct connect_options *opts)
+{
     c->opts = opts;
 }
 
-int client_connect(Client *c) {
+int client_connect(Client *c)
+{
     int fd = roach_connect(c->opts);
     if (fd < 0)
         return CLIENT_FAILURE;
@@ -90,7 +93,8 @@ int client_connect(Client *c) {
 
 void client_disconnect(Client *c) { close(c->fd); }
 
-int client_send_command(Client *c, char *buf) {
+int client_send_command(Client *c, char *buf)
+{
     uint8_t data[BUFSIZE];
     Request rq = {.length = strlen(buf) - 1};
     snprintf(rq.query, sizeof(rq.query), "%s", buf);
@@ -101,7 +105,8 @@ int client_send_command(Client *c, char *buf) {
     return write(c->fd, data, n);
 }
 
-int client_recv_response(Client *c, Response *rs) {
+int client_recv_response(Client *c, Response *rs)
+{
     uint8_t data[BUFSIZE];
     ssize_t n = read(c->fd, data, BUFSIZE);
     if (n < 0)

src/client.h

@@ -4,8 +4,8 @@
 #include <netdb.h>
 #include <stdio.h>
 
-#define CLIENT_SUCCESS 0
-#define CLIENT_FAILURE -1
+#define CLIENT_SUCCESS     0
+#define CLIENT_FAILURE     -1
 #define CLIENT_UNKNOWN_CMD -2
 
 typedef struct response Response;