Changed clang format style.

7 files changed, 212 insertions, 202 deletions

diff --git a/client/src/client/client.cpp b/client/src/client/client.cpp
index 4846440..3dd55fc 100644
--- a/client/src/client/client.cpp
+++ b/client/src/client/client.cpp
@@ -1,90 +1,93 @@
 #include "../include.h"
 #include "client.h"
 
-bool tcp::client::start(const std::string_view server_ip, const uint16_t port) {
-  SSL_library_init();
+bool tcp::client::start(const std::string_view server_ip, const uint16_t port)
+{
+    SSL_library_init();
 
-  m_ssl_ctx = SSL_CTX_new(TLS_client_method());
+    m_ssl_ctx = SSL_CTX_new(TLS_client_method());
 
-  m_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-  if (m_socket == -1) {
-    io::logger->error("failed to create socket.");
-    return false;
-  }
+    m_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+    if(m_socket == -1) {
+        io::logger->error("failed to create socket.");
+        return false;
+    }
 
-  sockaddr_in server_addr;
+    sockaddr_in server_addr;
 
-  server_addr.sin_family = AF_INET;
-  server_addr.sin_addr.s_addr = inet_addr(server_ip.data());
-  server_addr.sin_port = htons(port);
+    server_addr.sin_family      = AF_INET;
+    server_addr.sin_addr.s_addr = inet_addr(server_ip.data());
+    server_addr.sin_port        = htons(port);
 
-  int ret = connect(m_socket, reinterpret_cast<sockaddr *>(&server_addr),
-                    sizeof(server_addr));
-  if (ret < 0) {
-    io::logger->error("failed to connect to server.");
-    return false;
-  }
+    int ret =
+        connect(m_socket, reinterpret_cast<sockaddr*>(&server_addr), sizeof(server_addr));
+    if(ret < 0) {
+        io::logger->error("failed to connect to server.");
+        return false;
+    }
 
-  m_server_ssl = SSL_new(m_ssl_ctx);
-  SSL_set_fd(m_server_ssl, m_socket);
+    m_server_ssl = SSL_new(m_ssl_ctx);
+    SSL_set_fd(m_server_ssl, m_socket);
 
-  ret = SSL_connect(m_server_ssl);
+    ret = SSL_connect(m_server_ssl);
 
-  if (ret != 1) {
-    ret = SSL_get_error(m_server_ssl, ret);
-    io::logger->error("ssl connection failed, code {}", ret);
-    return false;
-  }
+    if(ret != 1) {
+        ret = SSL_get_error(m_server_ssl, ret);
+        io::logger->error("ssl connection failed, code {}", ret);
+        return false;
+    }
 
-  return true;
+    return true;
 }
 
-int tcp::client::read_stream(std::vector<char> &out) {
-  size_t size;
-  read(&size, sizeof(size));
+int tcp::client::read_stream(std::vector<char>& out)
+{
+    size_t size;
+    read(&size, sizeof(size));
 
-  size = ntohl(size);
-  out.resize(size);
+    size = ntohl(size);
+    out.resize(size);
 
-  constexpr size_t chunk_size = 4096;
-  size_t total = 0;
+    constexpr size_t chunk_size = 4096;
+    size_t           total      = 0;
 
-  while (size > 0) {
-    auto to_read = std::min(size, chunk_size);
+    while(size > 0) {
+        auto to_read = std::min(size, chunk_size);
 
-    int ret = read(&out[total], to_read);
-    if (ret <= 0) {
-      break;
-    }
+        int ret = read(&out[total], to_read);
+        if(ret <= 0) {
+            break;
+        }
 
-    size -= ret;
-    total += ret;
-  }
+        size -= ret;
+        total += ret;
+    }
 
-  return total;
+    return total;
 }
 
-int tcp::client::stream(std::vector<char> &data) {
-  auto size = data.size();
+int tcp::client::stream(std::vector<char>& data)
+{
+    auto size = data.size();
 
-  auto networked_size = htonl(size);
-  write(&networked_size, sizeof(networked_size));
+    auto networked_size = htonl(size);
+    write(&networked_size, sizeof(networked_size));
 
-  // with 4kb chunk size, speed peaks at 90mb/s
-  constexpr size_t chunk_size = 4096;
-  size_t sent = 0;
+    // with 4kb chunk size, speed peaks at 90mb/s
+    constexpr size_t chunk_size = 4096;
+    size_t           sent       = 0;
 
-  while (size > 0) {
-    auto to_send = std::min(size, chunk_size);
+    while(size > 0) {
+        auto to_send = std::min(size, chunk_size);
 
-    int ret = write(&data[sent], to_send);
-    if (ret <= 0) {
-      break;
-    }
+        int ret = write(&data[sent], to_send);
+        if(ret <= 0) {
+            break;
+        }
 
-    sent += ret;
-    size -= ret;
-  }
+        sent += ret;
+        size -= ret;
+    }
 
-  return sent;
+    return sent;
 }
diff --git a/client/src/client/client.h b/client/src/client/client.h
index 326bae6..2a3eee2 100644
--- a/client/src/client/client.h
+++ b/client/src/client/client.h
@@ -4,62 +4,61 @@
 #include "packet.h"
 
 namespace tcp {
-  
-enum client_state : uint8_t { idle = 0, active, standby };
 
-class client {
-  int m_socket;
-  std::atomic<uint8_t> m_state;
+    enum client_state : uint8_t { idle = 0, active, standby };
 
-  SSL *m_server_ssl;
-  SSL_CTX *m_ssl_ctx;
+    class client {
+        int                  m_socket;
+        std::atomic<uint8_t> m_state;
 
- public:
-  static constexpr int version = 0;
-  std::string session_id;
-  event<packet_t &> receive_event;
+        SSL*     m_server_ssl;
+        SSL_CTX* m_ssl_ctx;
 
-  client() : m_socket{-1}, m_state{0} {}
+    public:
+        static constexpr int version = 0;
+        std::string          session_id;
+        event<packet_t&>     receive_event;
 
-  bool start(const std::string_view server_ip, const uint16_t port);
+        client() : m_socket{ -1 }, m_state{ 0 } {}
 
-  int write(const packet_t &packet) {
-    if (!packet) return 0;
-    return SSL_write(m_server_ssl, packet.message.data(),
-                     packet.message.size());
-  }
+        bool start(const std::string_view server_ip, const uint16_t port);
 
-  int write(void *data, size_t size) {
-    return SSL_write(m_server_ssl, data, size);
-  }
+        int write(const packet_t& packet)
+        {
+            if(!packet)
+                return 0;
+            return SSL_write(m_server_ssl, packet.message.data(), packet.message.size());
+        }
 
-  int read(void *data, size_t size) {
-    return SSL_read(m_server_ssl, data, size);
-  }
+        int write(void* data, size_t size) { return SSL_write(m_server_ssl, data, size); }
 
-  int read_stream(std::vector<char> &out);
-  int stream(std::vector<char> &data);
+        int read(void* data, size_t size) { return SSL_read(m_server_ssl, data, size); }
 
-  int get_socket() { return m_socket; }
-  void set_state(const uint8_t state) { m_state = state; }
+        int read_stream(std::vector<char>& out);
+        int stream(std::vector<char>& data);
 
-  operator bool() const { return m_state == client_state::active; }
+        int  get_socket() { return m_socket; }
+        void set_state(const uint8_t state) { m_state = state; }
 
-  static void monitor(client &client) {
-    while (!client) std::this_thread::sleep_for(std::chrono::milliseconds(100));
+        operator bool() const { return m_state == client_state::active; }
 
-    std::array<char, message_len> buf;
-    while (client) {
-      int ret = client.read(&buf[0], buf.size());
-      if (ret <= 0) {
-        io::logger->error("connection lost.");
-        break;
-      }
-      std::string msg(buf.data(), ret);
-      packet_t packet(msg, packet_type::read);
+        static void monitor(client& client)
+        {
+            while(!client)
+                std::this_thread::sleep_for(std::chrono::milliseconds(100));
 
-      client.receive_event.call(packet);
-    }
-  }
-};
-}  // namespace tcp
+            std::array<char, message_len> buf;
+            while(client) {
+                int ret = client.read(&buf[0], buf.size());
+                if(ret <= 0) {
+                    io::logger->error("connection lost.");
+                    break;
+                }
+                std::string msg(buf.data(), ret);
+                packet_t    packet(msg, packet_type::read);
+
+                client.receive_event.call(packet);
+            }
+        }
+    };
+} // namespace tcp
diff --git a/client/src/client/packet.h b/client/src/client/packet.h
index 0a67303..05bdee2 100644
--- a/client/src/client/packet.h
+++ b/client/src/client/packet.h
@@ -1,51 +1,55 @@
 #pragma once
 
 namespace tcp {
-constexpr size_t session_id_len = 10;
-constexpr size_t message_len = 256 + session_id_len;
-
-enum packet_type : int { write = 0, read };
-
-struct packet_t {
-  std::string message;
-  char action;
-  std::string session_id;
-  int id;
-
-  packet_t() {}
-  packet_t(const std::string_view msg, const packet_type &type,
-           std::string_view session = "") {
-    if (type == read) {
-      ++id;
-
-      if (msg.size() < session_id_len) {
-        io::logger->error("packet message invalid!");
-        return;
-      }
-
-      session_id = msg.substr(0, session_id_len);
-
-      action = msg[session_id_len];
-      message = msg.substr(session_id_len);
-    } else {
-      session_id = session;
-
-      message = fmt::format("{}{}", session_id, msg);
-      
-      if(msg.size() > message_len) {
-        io::logger->error("packet message exceeds limit");
-        message.clear();
-        session_id.clear();
-        return;
-      }
-    }
-  }
-
-  ~packet_t() {
-    message.clear();
-    session_id.clear();
-  }
-
-  operator bool() const { return !message.empty() && !session_id.empty(); }
-};
-};  // namespace tcp
+    constexpr size_t session_id_len = 10;
+    constexpr size_t message_len    = 256 + session_id_len;
+
+    enum packet_type : int { write = 0, read };
+
+    struct packet_t {
+        std::string message;
+        char        action;
+        std::string session_id;
+        int         id;
+
+        packet_t() {}
+        packet_t(const std::string_view msg,
+                 const packet_type&     type,
+                 std::string_view       session = "")
+        {
+            if(type == read) {
+                ++id;
+
+                if(msg.size() < session_id_len) {
+                    io::logger->error("packet message invalid!");
+                    return;
+                }
+
+                session_id = msg.substr(0, session_id_len);
+
+                action  = msg[session_id_len];
+                message = msg.substr(session_id_len);
+            }
+            else {
+                session_id = session;
+
+                message = fmt::format("{}{}", session_id, msg);
+
+                if(msg.size() > message_len) {
+                    io::logger->error("packet message exceeds limit");
+                    message.clear();
+                    session_id.clear();
+                    return;
+                }
+            }
+        }
+
+        ~packet_t()
+        {
+            message.clear();
+            session_id.clear();
+        }
+
+        operator bool() const { return !message.empty() && !session_id.empty(); }
+    };
+}; // namespace tcp
diff --git a/client/src/main.cpp b/client/src/main.cpp
index 48a4e19..3cc3c77 100644
--- a/client/src/main.cpp
+++ b/client/src/main.cpp
@@ -2,39 +2,40 @@
 #include "util/io.h"
 #include "client/client.h"
 
-int main(int argc, char *argv[]) {
-  io::init();
+int main(int argc, char* argv[])
+{
+    io::init();
 
-  tcp::client client;
+    tcp::client client;
 
-  std::thread t{tcp::client::monitor, std::ref(client)};
-  t.detach();
+    std::thread t{ tcp::client::monitor, std::ref(client) };
+    t.detach();
 
-  if (client.start("127.0.0.1", 6666)) {
-    io::logger->info("connected.");
-    client.set_state(tcp::client_state::active);
-  }
+    if(client.start("127.0.0.1", 6666)) {
+        io::logger->info("connected.");
+        client.set_state(tcp::client_state::active);
+    }
 
-  client.receive_event.add([&](tcp::packet_t &packet) {
-    if (!packet) return;
+    client.receive_event.add([&](tcp::packet_t& packet) {
+        if(!packet)
+            return;
 
-    // first packet is the session id and current version
-    if (packet.id == 1) {
-      client.session_id = packet.session_id;
-      
-    }
+        // first packet is the session id and current version
+        if(packet.id == 1) {
+            client.session_id = packet.session_id;
+        }
 
-    io::logger->info("{}:{}->{}", packet.id, packet.session_id, packet.message);
-  });
+        io::logger->info("{}:{}->{}", packet.id, packet.session_id, packet.message);
+    });
 
-  while (client) {
-    std::string p;
-    getline(std::cin, p);
+    while(client) {
+        std::string p;
+        getline(std::cin, p);
 
-    int ret = client.write(
-        tcp::packet_t(p, tcp::packet_type::write, client.session_id));
-    if (ret <= 0) {
-      break;
+        int ret =
+            client.write(tcp::packet_t(p, tcp::packet_type::write, client.session_id));
+        if(ret <= 0) {
+            break;
+        }
     }
-  }
 }
diff --git a/client/src/util/events.h b/client/src/util/events.h
index b8d7781..04ad251 100644
--- a/client/src/util/events.h
+++ b/client/src/util/events.h
@@ -1,24 +1,27 @@
 #pragma once
 
-template <typename... Args>
+template<typename... Args>
 class event {
-  using func_type = std::function<void(Args...)>;
+    using func_type = std::function<void(Args...)>;
 
-  std::mutex event_lock;
-  std::list<func_type> m_funcs;
+    std::mutex           event_lock;
+    std::list<func_type> m_funcs;
 
- public:
-  void add(const func_type& func) {
-    std::lock_guard<std::mutex> lock(event_lock);
+public:
+    void add(const func_type& func)
+    {
+        std::lock_guard<std::mutex> lock(event_lock);
 
-    m_funcs.push_back(std::move(func));
-  }
+        m_funcs.push_back(std::move(func));
+    }
 
-  void call(Args... params) {
-    std::lock_guard<std::mutex> lock(event_lock);
+    void call(Args... params)
+    {
+        std::lock_guard<std::mutex> lock(event_lock);
 
-    for (auto& func : m_funcs) {
-      if (func) func(std::forward<Args>(params)...);
+        for(auto& func : m_funcs) {
+            if(func)
+                func(std::forward<Args>(params)...);
+        }
     }
-  }
 };
\ No newline at end of file
diff --git a/client/src/util/io.cpp b/client/src/util/io.cpp
index 06d2b9a..94f5575 100644
--- a/client/src/util/io.cpp
+++ b/client/src/util/io.cpp
@@ -3,10 +3,10 @@
 
 std::shared_ptr<spdlog::logger> io::logger;
 
-void io::init() {
-  spdlog::sink_ptr sink =
-      std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
-  sink->set_pattern("%^~>%$ %v");
+void io::init()
+{
+    spdlog::sink_ptr sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
+    sink->set_pattern("%^~>%$ %v");
 
-  logger = std::make_shared<spdlog::logger>("client", sink);
+    logger = std::make_shared<spdlog::logger>("client", sink);
 }
diff --git a/client/src/util/io.h b/client/src/util/io.h
index 8eae321..d5ab3be 100644
--- a/client/src/util/io.h
+++ b/client/src/util/io.h
@@ -1,7 +1,7 @@
 #pragma once
 
 namespace io {
-extern std::shared_ptr<spdlog::logger> logger;
+    extern std::shared_ptr<spdlog::logger> logger;
 
-void init();
-};  // namespace io
+    void init();
+}; // namespace io