refactor: format code

include/network/DataBuffer.h

@@ -7,9 +7,9 @@
 #include <cassert>
 #include <string>
 
-namespace td{
+namespace td {
 
-class DataBuffer{
+class DataBuffer {
 private:
     typedef std::vector<std::uint8_t> Data;
     Data m_Buffer;
@@ -31,7 +31,7 @@ public:
     DataBuffer& operator=(DataBuffer&& other);
 
     template <typename T>
-    void Append(T data){
+    void Append(T data) {
         std::size_t size = sizeof(data);
         std::size_t end_pos = m_Buffer.size();
         m_Buffer.resize(m_Buffer.size() + size);
@@ -39,30 +39,30 @@ public:
     }
 
     template <typename T>
-    DataBuffer& operator<<(T data){
+    DataBuffer& operator<<(T data) {
         // Switch to big endian
         //std::reverse((std::uint8_t*)&data, (std::uint8_t*)&data + sizeof(T));
         Append(data);
         return *this;
     }
 
-    DataBuffer& operator<<(std::string str){
-        m_Buffer.insert(m_Buffer.end(), str.begin(), str.end()); 
+    DataBuffer& operator<<(std::string str) {
+        m_Buffer.insert(m_Buffer.end(), str.begin(), str.end());
         return *this;
     }
 
-    DataBuffer& operator<<(DataBuffer& data){
+    DataBuffer& operator<<(DataBuffer& data) {
         m_Buffer.insert(m_Buffer.end(), data.begin(), data.end());
         return *this;
     }
 
-    DataBuffer& operator<<(const DataBuffer& data){
+    DataBuffer& operator<<(const DataBuffer& data) {
         m_Buffer.insert(m_Buffer.end(), data.begin(), data.end());
         return *this;
     }
 
     template <typename T>
-    DataBuffer& operator>>(T& data){
+    DataBuffer& operator>>(T& data) {
         assert(m_ReadOffset + sizeof(T) <= GetSize());
         data = *(T*)&m_Buffer[m_ReadOffset];
         //std::reverse((std::uint8_t*)&data, (std::uint8_t*)&data + sizeof(T));
@@ -70,77 +70,77 @@ public:
         return *this;
     }
 
-    DataBuffer& operator>>(DataBuffer& data){
+    DataBuffer& operator>>(DataBuffer& data) {
         data.Resize(GetSize() - m_ReadOffset);
         std::copy(m_Buffer.begin() + m_ReadOffset, m_Buffer.end(), data.begin());
         m_ReadOffset = m_Buffer.size();
         return *this;
     }
 
-    DataBuffer& operator>>(std::string& str){
-        std::size_t stringSize = strlen((const char*) m_Buffer.data() + m_ReadOffset) + 1; // including null character
+    DataBuffer& operator>>(std::string& str) {
+        std::size_t stringSize = strlen((const char*)m_Buffer.data() + m_ReadOffset) + 1; // including null character
         str.resize(stringSize);
         std::copy(m_Buffer.begin() + m_ReadOffset, m_Buffer.begin() + m_ReadOffset + stringSize, str.begin());
         m_ReadOffset += stringSize;
         return *this;
     }
 
-    void ReadSome(char* buffer, std::size_t amount){
+    void ReadSome(char* buffer, std::size_t amount) {
         assert(m_ReadOffset + amount <= GetSize());
         std::copy_n(m_Buffer.begin() + m_ReadOffset, amount, buffer);
         m_ReadOffset += amount;
     }
 
-    void ReadSome(std::uint8_t* buffer, std::size_t amount){
+    void ReadSome(std::uint8_t* buffer, std::size_t amount) {
         assert(m_ReadOffset + amount <= GetSize());
         std::copy_n(m_Buffer.begin() + m_ReadOffset, amount, buffer);
         m_ReadOffset += amount;
     }
 
-    void ReadSome(DataBuffer& buffer, std::size_t amount){
+    void ReadSome(DataBuffer& buffer, std::size_t amount) {
         assert(m_ReadOffset + amount <= GetSize());
         buffer.Resize(amount);
         std::copy_n(m_Buffer.begin() + m_ReadOffset, amount, buffer.begin());
         m_ReadOffset += amount;
     }
 
-    void ReadSome(std::string& buffer, std::size_t amount){
+    void ReadSome(std::string& buffer, std::size_t amount) {
         assert(m_ReadOffset + amount <= GetSize());
         buffer.resize(amount);
         std::copy_n(m_Buffer.begin() + m_ReadOffset, amount, buffer.begin());
         m_ReadOffset += amount;
     }
 
-    void Resize(std::size_t size){
+    void Resize(std::size_t size) {
         m_Buffer.resize(size);
     }
 
-    void Reserve(std::size_t amount){
+    void Reserve(std::size_t amount) {
         m_Buffer.reserve(amount);
     }
 
-    void erase(iterator it){
+    void erase(iterator it) {
         m_Buffer.erase(it);
     }
 
-    void Clear(){
+    void Clear() {
         m_Buffer.clear();
         m_ReadOffset = 0;
     }
 
-    bool IsFinished() const{
+    bool IsFinished() const {
         return m_ReadOffset >= m_Buffer.size();
     }
 
-    std::uint8_t* data(){
+    std::uint8_t* data() {
         return m_Buffer.data();
     }
 
-    const std::uint8_t* data() const{
+    const std::uint8_t* data() const {
         return m_Buffer.data();
     }
 
-    std::size_t GetReadOffset() const{ return m_ReadOffset; }
+    std::size_t GetReadOffset() const { return m_ReadOffset; }
     void  SetReadOffset(std::size_t pos);
 
     std::string  ToString() const;
@@ -153,8 +153,8 @@ public:
     const_iterator  begin() const;
     const_iterator  end() const;
 
-    reference operator[](Data::size_type i){ return m_Buffer[i]; }
-    const_reference operator[](Data::size_type i) const{ return m_Buffer[i]; }
+    reference operator[](Data::size_type i) { return m_Buffer[i]; }
+    const_reference operator[](Data::size_type i) const { return m_Buffer[i]; }
 
     bool ReadFile(const std::string& fileName);
     bool WriteFile(const std::string& fileName);

include/network/TCPListener.h

@@ -1,10 +1,10 @@
 #pragma once
 #include "TCPSocket.h"
 
-namespace td{
-namespace network{
+namespace td {
+namespace network {
 
-class TCPListener{
+class TCPListener {
     int m_Handle;
     std::uint16_t m_Port;
     int m_MaxConnections;
@@ -20,10 +20,10 @@ public:
     bool close();
     bool setBlocking(bool blocking);
 
-    std::uint16_t getListeningPort() const{
+    std::uint16_t getListeningPort() const {
         return m_Port;
     }
-    int getMaximumConnections() const{
+    int getMaximumConnections() const {
         return m_MaxConnections;
     }