User construct/Add trans changes

once again this has many errors but ill merge and fix

config.json

@@ -1,16 +1,9 @@
 {
-  "listeners": [
+	"listeners": [
-      {
+		{
-        "address": "0.0.0.0",
+			"address": "127.0.0.1",
-        "port": 80,
+			"port": 80,
-        "https": false
+			"https": false
-      },
+		}
-      {
+	]
-        "address": "0.0.0.0",
-        "port": 443,
-        "https": true,
-        "cert": "",
-        "key": ""
-      }
-  ]
 }

include/log.hpp

@@ -7,31 +7,22 @@
 struct Log
 {
     std::vector<Transaction> data;
-    void AddTrans(Transaction &&v)
+    void AddTrans(Transaction &&t)
     {
-        if (data.capacity() == data.size() && data.size() < max_log_size) //if memory reserved is full and max isnt reached
+        if (data.size() == max_log_size) // If we hit the max size
         {
-            if (data.size() + pre_log_size > max_log_size) //if prefetched memory is larger then max
+            for (uint32_t i = 0; i < data.size() - 1; i--) // Make room at the back
             {
-                data.reserve(max_log_size); //just allocate max
+                data[i - 1] = std::move(data[i]); // Shifts everything left
-            }
-            else
-            {
-                data.reserve(data.size() + pre_log_size); //prefetching memory
             }
+            data[data.size() - 1] = std::move(t); // Place new in opened spot
+            return;
         }
-        if (data.size() == max_log_size)
+        else if (data.size() == data.capacity()) // If we haven't hit the max but hit capacity
         {
-            for (size_t i = 0; i < data.size() - 1; ++i)
+            data.reserve(data.capacity() + pre_log_size); // Reserve more memory
-            {
-                data[i] = std::move(data[i + 1]);
-            }
-            data[data.size() - 1] = std::move(v);
-        }
-        else
-        {
-            data.push_back(std::move(v));
         }
+        data.push_back(std::move(t)); // In either case we have space under max length, move to new spot
     }
     Json::Value Serialize() const
     {

include/user.hpp

@@ -36,17 +36,16 @@ struct User
     {
         if (log_j.size())
         {
-            unsigned size = ((log_j.size() / pre_log_size) + 1) * pre_log_size; // Ensures that we have a log size aligned on a multiple of `pre_log_size`
+            uint32_t newLogSize = std::min(pre_log_size * ((log_j.size() / pre_log_size) + 1), max_log_size);
-            log.data.reserve(size);                                             // Ensures that the log size is under `max_log_size`
+            log.data.reserve(newLogSize);
-            size = std::min(log_j.size(), max_log_size);
+            for (uint32_t i = (log_j.size() - max_log_size) * (log_j.size() > max_log_size); i < log_j.size(); i++) 
-            log.data.resize(size);
-            for (uint32_t i = 0; i < size; ++i)
             {
-                log.data[i] = std::move(Transaction(
+                log.data.push_back(std::move(Transaction( // Push back because `i` is not at the beginning 
-                    log_j[i]["from"].asCString(),
+                    log_j[i]["from"].asCString(),         // and no array creation with `vector::resize()`
                     log_j[i]["to"].asCString(),
                     log_j[i]["amount"].asUInt(),
-                    log_j[i]["time"].asUInt64()));
+                    log_j[i]["time"].asUInt64()
+                )));
             }
         }
     }

main.cpp

@@ -22,15 +22,9 @@ void SaveSig(int s)
 
 int main(int argc, char **argv)
 {
-    static_assert(pre_log_size <= max_log_size, "`max_log_size` must be larger than `pre_log_size`.");
+    // Static assertations for logging only (!max_log_size)
-    if constexpr (max_log_size)
+    static_assert(!max_log_size || pre_log_size < max_log_size, "`max_log_size` must be larger than `pre_log_size`.");
-    {
+    static_assert(!max_log_size || !(max_log_size % pre_log_size), "`max_log_size` must be a multiple of `pre_log_size`.");
-        if (max_log_size % pre_log_size)
-        {
-            std::cerr << "`max_log_size` must be a multiple of `pre_log_size`.";
-            return 0;
-        }
-    }
 
     if (argc != 4)
     {