fix(clang-tidy): Fixing the warning from clang-tidy of signal and message source files

Author: LinuxDevon

include/libdbc/message.hpp

@@ -24,7 +24,7 @@ struct Message {
 	ParseSignalsStatus parseSignals(const std::vector<uint8_t>& data, std::vector<double>& values) const;
 
 	void appendSignal(const Signal& signal);
-	const std::vector<Signal> getSignals() const;
+	std::vector<Signal> getSignals() const;
 	uint32_t id() const;
 	uint8_t size() const;
 	const std::string& name() const;

src/message.cpp

@@ -1,10 +1,17 @@
-#include <algorithm>
 #include <cstdint>
 #include <libdbc/message.hpp>
 
 namespace libdbc {
-Message::Message(uint32_t id, const std::string& name, uint8_t size, const std::string& node)
-	: m_id(id)
+
+constexpr unsigned ONE_BYTE = 8;
+constexpr unsigned TWO_BYTES = 16;
+constexpr unsigned FOUR_BYTES = 32;
+constexpr unsigned EIGHT_BYTES = 64;
+
+constexpr unsigned SEVEN_BITS = 7;
+
+Message::Message(uint32_t message_id, const std::string& name, uint8_t size, const std::string& node)
+	: m_id(message_id)
 	, m_name(name)
 	, m_size(size)
 	, m_node(node) {
@@ -16,61 +23,61 @@ bool Message::operator==(const Message& rhs) const {
 
 Message::ParseSignalsStatus Message::parseSignals(const std::vector<uint8_t>& data, std::vector<double>& values) const {
 	auto size = data.size();
-	if (size > 8) {
+	if (size > ONE_BYTE) {
 		return ParseSignalsStatus::ErrorMessageToLong; // not supported yet
 	}
 
 	uint64_t data_little_endian = 0;
 	uint64_t data_big_endian = 0;
 	for (size_t i = 0; i < size; i++) {
-		data_little_endian |= ((uint64_t)data[i]) << i * 8;
-		data_big_endian = (data_big_endian << 8) | (uint64_t)data[i];
+		data_little_endian |= ((uint64_t)data[i]) << i * ONE_BYTE;
+		data_big_endian = (data_big_endian << ONE_BYTE) | (uint64_t)data[i];
 	}
 
 	// TODO: does this also work on a big endian machine?
 
 	const auto len = size * 8;
-	uint64_t v = 0;
+	uint64_t value = 0;
 	for (const auto& signal : m_signals) {
 		if (signal.is_bigendian) {
-			uint32_t start_bit = 8 * (signal.start_bit / 8) + (7 - (signal.start_bit % 8)); // Calculation taken from python CAN
-			v = data_big_endian << start_bit;
-			v = v >> (len - signal.size);
+			uint32_t start_bit = ONE_BYTE * (signal.start_bit / ONE_BYTE) + (SEVEN_BITS - (signal.start_bit % ONE_BYTE)); // Calculation taken from python CAN
+			value = data_big_endian << start_bit;
+			value = value >> (len - signal.size);
 		} else {
-			v = data_little_endian >> signal.start_bit;
+			value = data_little_endian >> signal.start_bit;
 		}
 
 		if (signal.is_signed && signal.size > 1) {
 			switch (signal.size) {
-			case 8:
-				values.push_back(static_cast<int8_t>(v) * signal.factor + signal.offset);
+			case ONE_BYTE:
+				values.push_back(static_cast<int8_t>(value) * signal.factor + signal.offset);
 				break;
-			case 16:
-				values.push_back(static_cast<int16_t>(v) * signal.factor + signal.offset);
+			case TWO_BYTES:
+				values.push_back(static_cast<int16_t>(value) * signal.factor + signal.offset);
 				break;
-			case 32:
-				values.push_back(static_cast<int32_t>(v) * signal.factor + signal.offset);
+			case FOUR_BYTES:
+				values.push_back(static_cast<int32_t>(value) * signal.factor + signal.offset);
 				break;
-			case 64:
-				values.push_back(static_cast<double>(v) * signal.factor + signal.offset);
+			case EIGHT_BYTES:
+				values.push_back(static_cast<double>(value) * signal.factor + signal.offset);
 				break;
 			default: {
 				// 2 complement -> decimal
-				const int negative = (v & (1ull << (signal.size - 1))) != 0;
-				int64_t nativeInt;
-				if (negative) {
-					nativeInt = static_cast<int64_t>(v | ~((1ull << signal.size) - 1)); // invert all bits above signal.size
+				const bool is_negative = (value & (1ULL << (signal.size - 1))) != 0;
+				int64_t nativeInt = 0;
+				if (is_negative) {
+					nativeInt = static_cast<int64_t>(value | ~((1ULL << signal.size) - 1)); // invert all bits above signal.size
 				} else {
-					nativeInt = static_cast<int64_t>(v & ((1ull << signal.size) - 1)); // masking
+					nativeInt = static_cast<int64_t>(value & ((1ULL << signal.size) - 1)); // masking
 				}
 				values.push_back(static_cast<double>(nativeInt) * signal.factor + signal.offset);
 				break;
 			}
 			}
 		} else {
 			// use only the relevant bits
-			v = v & ((1 << signal.size) - 1); // masking
-			values.push_back(static_cast<double>(v) * signal.factor + signal.offset);
+			value = value & ((1 << signal.size) - 1); // masking
+			values.push_back(static_cast<double>(value) * signal.factor + signal.offset);
 		}
 	}
 	return ParseSignalsStatus::Success;
@@ -80,7 +87,7 @@ void Message::appendSignal(const Signal& signal) {
 	m_signals.push_back(signal);
 }
 
-const std::vector<Signal> Message::getSignals() const {
+std::vector<Signal> Message::getSignals() const {
 	return m_signals;
 }
 
@@ -96,10 +103,10 @@ const std::string& Message::name() const {
 	return m_name;
 }
 
-void Message::addValueDescription(const std::string& signal_name, const std::vector<Signal::SignalValueDescriptions>& vd) {
-	for (auto& s : m_signals) {
-		if (s.name.compare(signal_name) == 0) {
-			s.svDescriptions = vd;
+void Message::addValueDescription(const std::string& signal_name, const std::vector<Signal::SignalValueDescriptions>& value_descriptor) {
+	for (auto& signal : m_signals) {
+		if (signal.name == signal_name) {
+			signal.svDescriptions = value_descriptor;
 			return;
 		}
 	}

src/signal.cpp

@@ -47,8 +47,8 @@ std::ostream& operator<<(std::ostream& out, const Signal& sig) {
 	out << "Min: " << sig.min << ", Max: " << sig.max << ", ";
 	out << "Unit: (" << sig.unit << "), ";
 	out << "receivers: ";
-	for (const auto& r : sig.receivers) {
-		out << r;
+	for (const auto& reciever : sig.receivers) {
+		out << reciever;
 	}
 	return out << "}";
 }