snake case for bytearray

Author: w0lek

vpr/src/server/bytearray.h

@@ -27,8 +27,8 @@ class ByteArray : public std::vector<uint8_t> {
                                reinterpret_cast<const uint8_t*>(data + size))
     {}
 
-    ByteArray(std::size_t sizeHint = DEFAULT_SIZE_HINT) {
-        reserve(sizeHint);
+    ByteArray(std::size_t size_hint = DEFAULT_SIZE_HINT) {
+        reserve(size_hint);
     }
 
     template<typename Iterator>
@@ -42,12 +42,12 @@ class ByteArray : public std::vector<uint8_t> {
         push_back(b);
     }
 
-    std::size_t findSequence(const char* sequence, std::size_t sequenceSize) {
-        const std::size_t mSize = size();
-        if (mSize >= sequenceSize) {
-            for (std::size_t i = 0; i <= mSize - sequenceSize; ++i) {
+    std::size_t find_sequence(const char* sequence, std::size_t sequence_size) {
+        const std::size_t ssize = size();
+        if (ssize >= sequence_size) {
+            for (std::size_t i = 0; i <= ssize - sequence_size; ++i) {
                 bool found = true;
-                for (std::size_t j = 0; j < sequenceSize; ++j) {
+                for (std::size_t j = 0; j < sequence_size; ++j) {
                     if (at(i + j) != sequence[j]) {
                         found = false;
                         break;
@@ -65,12 +65,12 @@ class ByteArray : public std::vector<uint8_t> {
         return std::string(reinterpret_cast<const char*>(this->data()), this->size());
     }
 
-    uint32_t calcCheckSum() {
-        return calcCheckSum<ByteArray>(*this);
+    uint32_t calc_check_sum() {
+        return calc_check_sum<ByteArray>(*this);
     }
 
     template<typename T>
-    static uint32_t calcCheckSum(const T& iterable) {
+    static uint32_t calc_check_sum(const T& iterable) {
         uint32_t sum = 0;
         for (uint8_t c : iterable) {
             sum += static_cast<unsigned int>(c);

vpr/src/server/telegrambuffer.cpp

@@ -9,7 +9,7 @@ void TelegramBuffer::append(const ByteArray& bytes) {
 }
 
 bool TelegramBuffer::check_telegram_header_presence() {
-    std::size_t signature_start_index = m_raw_buffer.findSequence(TelegramHeader::SIGNATURE, TelegramHeader::SIGNATURE_SIZE);
+    std::size_t signature_start_index = m_raw_buffer.find_sequence(TelegramHeader::SIGNATURE, TelegramHeader::SIGNATURE_SIZE);
     if (signature_start_index != std::size_t(-1)) {
         if (signature_start_index != 0) {
             // discard bytes preceding the header start position.
@@ -45,7 +45,7 @@ void TelegramBuffer::take_telegram_frames(std::vector<comm::TelegramFramePtr>& r
             if (m_raw_buffer.size() >= expected_telegram_size) {
                 // checksum validation
                 ByteArray data(m_raw_buffer.begin() + TelegramHeader::size(), m_raw_buffer.begin() + expected_telegram_size);
-                uint32_t actual_check_sum = data.calcCheckSum();
+                uint32_t actual_check_sum = data.calc_check_sum();
                 if (actual_check_sum == header.body_check_sum()) {
                     // construct telegram frame if checksum matches
                     TelegramFramePtr telegram_frame_ptr = std::make_shared<TelegramFrame>(TelegramFrame{header, std::move(data)});

vpr/src/server/telegramheader.h

@@ -44,7 +44,7 @@ class TelegramHeader {
 
     template<typename T>
     static comm::TelegramHeader construct_from_data(const T& body, uint8_t compressor_id = 0) {
-        uint32_t body_check_sum = ByteArray::calcCheckSum(body);
+        uint32_t body_check_sum = ByteArray::calc_check_sum(body);
         return comm::TelegramHeader{static_cast<uint32_t>(body.size()), body_check_sum, compressor_id};
     }