chore: formatting

tricktux · tricktux · commit f52c9458a7d3 · 2024-12-04T05:47:14.000-05:00
diff --git a/source/means-to-an-end/main.c b/source/means-to-an-end/main.c
@@ -31,7 +31,7 @@
 #define MAX_EVENTS 10
 #define PORT "18888"
 
-int handle_request(struct queue *sdq, char* raw_req, size_t size)
+int handle_request(struct queue* sdq, char* raw_req, size_t size)
 {
   assert(sdq != NULL);
   assert(raw_req != NULL);
@@ -44,8 +44,8 @@ int handle_request(struct queue *sdq, char* raw_req, size_t size)
   bool mal = false;
   /*int r = is_prime_request_builder(sdq, raw_req, size, &mal);*/
   /*if (r <= 0) {*/
-    /*log_warn("recv_and_handle: is_prime_request_builder returned '%d'", r);*/
-    /*return -1;*/
+  /*log_warn("recv_and_handle: is_prime_request_builder returned '%d'", r);*/
+  /*return -1;*/
   /*}*/
 
   return (mal ? 0 : 1);
@@ -90,7 +90,7 @@ int main()
   char *data, *sddata, *complete_req;
   int n, fd, res, size, sdsize, rs, result;
   struct epoll_ctl_info epci = {epollfd, 0, 0};
-  struct queue* rcqu = NULL, *sdqu = NULL;
+  struct queue *rcqu = NULL, *sdqu = NULL;
   queue_init(&rcqu, QUEUE_CAPACITY);
   queue_init(&sdqu, QUEUE_CAPACITY);
 
@@ -116,7 +116,10 @@ int main()
 
       // Receive all the data into the queue
       res = recv_request(fd, rcqu);
-      log_trace("main epoll loop: handling POLLIN event on fd '%d' with res: '%d'", fd, res);
+      log_trace(
+          "main epoll loop: handling POLLIN event on fd '%d' with res: '%d'",
+          fd,
+          res);
 
       // Handle error case while recv data
       if (res < -1) {
@@ -133,23 +136,33 @@ int main()
       complete_req = NULL;
       size = queue_peek(rcqu, &data);
       if (size > 0) {
-        /*complete_req = (char *) memrchr(data, PRIME_REQUEST_DELIMITERS[0], size);*/
-        log_trace("main epoll loop: complete_req = '%d'", (complete_req == NULL ? 0 : 1));
+        /*complete_req = (char *) memrchr(data, PRIME_REQUEST_DELIMITERS[0],
+         * size);*/
+        log_trace("main epoll loop: complete_req = '%d'",
+                  (complete_req == NULL ? 0 : 1));
       }
 
       // If we do, process it
       if (complete_req != NULL) {
         size = queue_pop_no_copy(rcqu, &data);
-        log_trace("main epoll loop: raw request: fd: '%d', size: '%d', data: '%s'", fd, size, data);
+        log_trace(
+            "main epoll loop: raw request: fd: '%d', size: '%d', data: '%s'",
+            fd,
+            size,
+            data);
         result = handle_request(sdqu, data, (size_t)size);
         sdsize = queue_pop_no_copy(sdqu, &sddata);
         rs = sendall(fd, sddata, &sdsize);
 
         if ((result <= 0) || (rs != 0)) {
           if (result == 0)
-            log_info("main epoll loop: there was a malformed respoonse. need to close socket");
+            log_info(
+                "main epoll loop: there was a malformed respoonse. need to "
+                "close socket");
           else if (result < 0)
-            log_info("main epoll loop: there was an error handling the request. need to close socket");
+            log_info(
+                "main epoll loop: there was an error handling the request. "
+                "need to close socket");
           else if (rs != 0)
             log_error("main epoll loop:: failed during sendall function");
           if (fd_poll_del_and_close(&epci) == -1) {
diff --git a/source/means-to-an-end/messages.c b/source/means-to-an-end/messages.c
@@ -7,37 +7,36 @@
 #include "means-to-an-end/prices.h"
 #include "means-to-an-end/messages.h"
 
-void message_parse(struct queue* sdqu, char *data, size_t dsize) {
+void message_parse(struct queue* sdqu, char* data, size_t dsize)
+{
   // TODO: create and allocate struct prices
-  char *pd = data;
+  char* pd = data;
   int k;
   int num_msgs = dsize / MESSAGE_SIZE;
   for (k = 0; k < num_msgs; pd += MESSAGE_SIZE) {
     char type = *pd;
-    uint32_t *first_word = (uint32_t *)(pd + MESSAGE_FIRST_WORD_OFFSET);
-    uint32_t *second_word = (uint32_t *)(pd + MESSAGE_SECOND_WORD_OFFSET);
+    uint32_t* first_word = (uint32_t*)(pd + MESSAGE_FIRST_WORD_OFFSET);
+    uint32_t* second_word = (uint32_t*)(pd + MESSAGE_SECOND_WORD_OFFSET);
 
     switch (type) {
-      case MESSAGE_QUERY:
-        {
-          struct price_query qry;
-          qry.mintime = ntohl(*first_word);
-          qry.maxtime = ntohl(*second_word);
-          // Process query...
-          break;
-        }
-      case MESSAGE_INSERT:
-        {
-          struct price prc;
-          prc.timestamp = ntohl(*first_word);
-          prc.price = ntohl(*second_word);
-          // Insert price directly into vector without additional memcpy
-          /*if (p->size == p->capacity) {*/
-            // Resize logic here
-          /*}*/
-          /*p->data[p->size++] = prc;*/
-          break;
-        }
+      case MESSAGE_QUERY: {
+        struct price_query qry;
+        qry.mintime = ntohl(*first_word);
+        qry.maxtime = ntohl(*second_word);
+        // Process query...
+        break;
+      }
+      case MESSAGE_INSERT: {
+        struct price prc;
+        prc.timestamp = ntohl(*first_word);
+        prc.price = ntohl(*second_word);
+        // Insert price directly into vector without additional memcpy
+        /*if (p->size == p->capacity) {*/
+        // Resize logic here
+        /*}*/
+        /*p->data[p->size++] = prc;*/
+        break;
+      }
       default:
         // Handle unknown message type
         break;
diff --git a/source/means-to-an-end/messages.h b/source/means-to-an-end/messages.h
@@ -5,10 +5,9 @@
 #define MESSAGE_SIZE 9
 #define MESSAGE_INSERT 'I'
 #define MESSAGE_QUERY 'Q'
-#define MESSAGE_FIRST_WORD_OFFSET 1   // These are in network byte order
-#define MESSAGE_SECOND_WORD_OFFSET 5   // These are in network byte order
+#define MESSAGE_FIRST_WORD_OFFSET 1  // These are in network byte order
+#define MESSAGE_SECOND_WORD_OFFSET 5  // These are in network byte order
 
-void message_parse(struct queue* sdqu, char *data, size_t dsize);
+void message_parse(struct queue* sdqu, char* data, size_t dsize);
 
 #endif  // INCLUDE_MESSAGES_H_
-
diff --git a/source/means-to-an-end/prices.c b/source/means-to-an-end/prices.c
@@ -7,20 +7,22 @@
 
 #include "means-to-an-end/prices.h"
 
-void prices_init_data(struct prices *ps, size_t capacity) {
+void prices_init_data(struct prices* ps, size_t capacity)
+{
   assert(ps != NULL);
   assert(capacity > 0);
   assert(capacity > ps->capacity);
 
-  struct price *new_data = NULL;
+  struct price* new_data = NULL;
   new_data = reallocarray(ps->data, sizeof(struct price), capacity);
   assert(new_data != NULL);
 
   ps->data = new_data;
   ps->capacity = capacity;
 }
 
-void prices_init(struct prices **pps, size_t capacity) {
+void prices_init(struct prices** pps, size_t capacity)
+{
   assert(capacity > 0);
 
   *pps = malloc(sizeof(struct prices));
@@ -32,7 +34,8 @@ void prices_init(struct prices **pps, size_t capacity) {
   (*pps)->size = 0;
 }
 
-void prices_free(struct prices **pps) {
+void prices_free(struct prices** pps)
+{
   assert(*pps != NULL);
   assert((*pps)->data != NULL);
 
@@ -45,7 +48,8 @@ void prices_free(struct prices **pps) {
 //   - Check prices with the same timestamp
 //     - Don't add new prices on timestamp conflict
 //   - After push, sort, to keep the array sorted
-void prices_push(struct prices *ps, struct price* data) {
+void prices_push(struct prices* ps, struct price* data)
+{
   assert(ps != NULL);
   assert(ps->data != NULL);
   assert(data != NULL);
@@ -57,7 +61,7 @@ void prices_push(struct prices *ps, struct price* data) {
   ps->data[ps->size++] = *data;
 }
 
-bool prices_duplicate_timestamp_check(struct prices *ps, int32_t timestamp)
+bool prices_duplicate_timestamp_check(struct prices* ps, int32_t timestamp)
 {
   assert(ps != NULL);
   assert(ps->data != NULL);
@@ -96,7 +100,6 @@ void prices_binary_sort(struct prices* ps)
   }
 }
 
-/*If there are no samples within the requested period, or if mintime comes after maxtime, the value returned must be 0.*/
-int32_t prices_query(struct prices *ps, struct price_query *pq) {
-
-}
+/*If there are no samples within the requested period, or if mintime comes after
+ * maxtime, the value returned must be 0.*/
+int32_t prices_query(struct prices* ps, struct price_query* pq) {}
diff --git a/source/means-to-an-end/prices.h b/source/means-to-an-end/prices.h
@@ -6,36 +6,36 @@ extern "C" {
 #endif
 
 struct price {
-  int32_t timestamp; // In epoch
+  int32_t timestamp;  // In epoch
   int32_t price;
 };
 
 struct price_query {
-  int32_t mintime; // In epoch
+  int32_t mintime;  // In epoch
   int32_t maxtime;
 };
 
 // Array structure
 struct prices {
-  struct price *data;
-  size_t size;    // Number of struct price we are holding
+  struct price* data;
+  size_t size;  // Number of struct price we are holding
   size_t capacity;  // Not bytes, but number struct price we can hold
 };
 
-void prices_init(struct prices **pps, size_t capacity);
-void prices_init_data(struct prices *ps, size_t capacity);
-void prices_free(struct prices **pps);
+void prices_init(struct prices** pps, size_t capacity);
+void prices_init_data(struct prices* ps, size_t capacity);
+void prices_free(struct prices** pps);
 // TODO: On push
 //   - Check prices with the same timestamp
 //     - Don't add new prices on timestamp conflict
 //   - After push, sort, to keep the array sorted
-void prices_push(struct prices *ps, struct price* data);
+void prices_push(struct prices* ps, struct price* data);
 // Get pointer to the data
-void prices_binary_sort(struct prices *ps);
-bool prices_duplicate_timestamp_check(struct prices *ps, int32_t timestamp);
-/*If there are no samples within the requested period, or if mintime comes after maxtime, the value returned must be 0.*/
-int32_t prices_query(struct prices *ps, struct price_query *pq);
-
+void prices_binary_sort(struct prices* ps);
+bool prices_duplicate_timestamp_check(struct prices* ps, int32_t timestamp);
+/*If there are no samples within the requested period, or if mintime comes after
+ * maxtime, the value returned must be 0.*/
+int32_t prices_query(struct prices* ps, struct price_query* pq);
 
 #ifdef __cplusplus
 }
diff --git a/source/prime-time/is-prime-request.c b/source/prime-time/is-prime-request.c
@@ -26,9 +26,10 @@
 #include "prime-time/is-prime-request.h"
 
 /// Return the number of requests processed
-int is_prime_request_builder(struct queue *sdq,
+int is_prime_request_builder(struct queue* sdq,
                              char* raw_request,
-                             size_t req_size, bool *malformed)
+                             size_t req_size,
+                             bool* malformed)
 {
   assert(sdq != NULL);
   assert(malformed != NULL);
@@ -45,13 +46,13 @@ int is_prime_request_builder(struct queue *sdq,
     if (token == NULL)
       break;
     // We have exceeded the request size
-    if ((token - raw_request) >= (long) req_size)
+    if ((token - raw_request) >= (long)req_size)
       break;
 
     *malformed = is_prime_request_malformed(&curr, token);
     curr.is_prime = is_prime_f(curr.number);
     is_prime_beget_response(&curr, sdq->head, &size);
-    queue_push_ex(sdq, (size_t) size);
+    queue_push_ex(sdq, (size_t)size);
 
     // Stop handling requests for this socket as soon as we
     // find a malformed request
@@ -72,7 +73,7 @@ void is_prime_init(struct is_prime_request** request)
   (*request)->number = 0;
 }
 
-bool is_prime_request_malformed(struct is_prime_request *request, char* req)
+bool is_prime_request_malformed(struct is_prime_request* request, char* req)
 {
   assert(request != NULL);
   assert(req != NULL);
@@ -99,8 +100,7 @@ bool is_prime_request_malformed(struct is_prime_request *request, char* req)
 
   if (json_object_get_type(method) != json_type_string) {
     json_object_put(root);
-    log_warn(
-      "is_prime_request_malformed: method is not of type string");
+    log_warn("is_prime_request_malformed: method is not of type string");
     request->is_malformed = true;
     return true;
   }
@@ -149,8 +149,7 @@ bool is_prime_request_malformed(struct is_prime_request *request, char* req)
 
   if (num_type != json_type_int) {
     json_object_put(root);
-    log_warn(
-      "is_prime_request_malformed: number is not of type int");
+    log_warn("is_prime_request_malformed: number is not of type int");
     request->is_malformed = true;
     return true;
   }
@@ -159,9 +158,8 @@ bool is_prime_request_malformed(struct is_prime_request *request, char* req)
   int number_value = json_object_get_int(number);
   if (errno != 0) {
     json_object_put(root);
-    log_warn(
-        "is_prime_request_malformed: json_object_get_int failed for '%s'",
-        number);
+    log_warn("is_prime_request_malformed: json_object_get_int failed for '%s'",
+             number);
     request->is_malformed = true;
     return true;
   }
@@ -185,21 +183,22 @@ bool is_prime_f(int number)
   return true;
 }
 
-void is_prime_beget_response(struct is_prime_request* request, char *response, int *size)
+void is_prime_beget_response(struct is_prime_request* request,
+                             char* response,
+                             int* size)
 {
   assert(request != NULL);
   assert(response != NULL);
   assert(size != NULL);
 
   if (request->is_malformed) {
     *size = PRIME_RESPONSE_ILL_RESPONSE_SIZE;
-    memcpy(response, PRIME_RESPONSE_ILL_RESPONSE, (size_t) *size);
+    memcpy(response, PRIME_RESPONSE_ILL_RESPONSE, (size_t)*size);
     log_trace("is_prime_beget_response: '%s'", response);
     return;
   }
-  *size = sprintf(response,
-          PRIME_RESPONSE_FORMAT,
-          (request->is_prime ? "true" : "false"));
+  *size = sprintf(
+      response, PRIME_RESPONSE_FORMAT, (request->is_prime ? "true" : "false"));
   log_trace("is_prime_beget_response: '%s'", response);
 }
 
diff --git a/source/prime-time/is-prime-request.h b/source/prime-time/is-prime-request.h
@@ -23,12 +23,15 @@ struct is_prime_request {
   int number;
 };
 
-int is_prime_request_builder(struct queue *sdq,
+int is_prime_request_builder(struct queue* sdq,
                              char* raw_request,
-                             size_t req_size, bool *malformed);
-bool is_prime_request_malformed(struct is_prime_request *request, char* req);
+                             size_t req_size,
+                             bool* malformed);
+bool is_prime_request_malformed(struct is_prime_request* request, char* req);
 bool is_prime_f(int number);
-void is_prime_beget_response(struct is_prime_request* request, char *response, int *size);
+void is_prime_beget_response(struct is_prime_request* request,
+                             char* response,
+                             int* size);
 void is_prime_init(struct is_prime_request** request);
 void is_prime_free(struct is_prime_request** request);
 
diff --git a/source/prime-time/main.c b/source/prime-time/main.c
diff --git a/test/is-prime/is-prime-request-test.cpp b/test/is-prime/is-prime-request-test.cpp
diff --git a/test/means-to-an-end/messages-prices-test.cpp b/test/means-to-an-end/messages-prices-test.cpp
