fix clang-format

Author: Alexey Zharkov

source/connection/flow/tcp/tcp_flow.cpp

@@ -46,12 +46,14 @@ TcpFlow::TcpFlow(Id a_id, std::shared_ptr<IConnection> a_conn,
 }
 
 void TcpFlow::update(Packet packet) {
-    utils::StrExpected<PacketFlagsBase> exp_packet_type_label_flag = packet.flags.get_flag(m_packet_type_label);
+    utils::StrExpected<PacketFlagsBase> exp_packet_type_label_flag =
+        packet.flags.get_flag(m_packet_type_label);
     if (!exp_packet_type_label_flag.has_value()) {
         LOG_ERROR(std::move(exp_packet_type_label_flag.error()));
     }
 
-    PacketType type = static_cast<PacketType>(exp_packet_type_label_flag.value());
+    PacketType type =
+        static_cast<PacketType>(exp_packet_type_label_flag.value());
     if (m_src.expired()) {
         LOG_ERROR(fmt::format("Sender exprired for flow {}; ignore packet {}",
                               to_string(), packet.to_string()));
@@ -321,13 +323,11 @@ void TcpFlow::process_ack(Packet ack, std::size_t confirm_count) {
 Packet TcpFlow::generate_data_packet(PacketNum packet_num) {
     Packet packet;
     packet.flags = get_flag_manager();
-    auto result = packet.flags.set_flag(m_packet_type_label,
-                            PacketType::DATA);
+    auto result = packet.flags.set_flag(m_packet_type_label, PacketType::DATA);
     if (!result.has_value()) {
         LOG_ERROR(std::move(result.error()));
     }
 
-
     set_avg_rtt_if_present(packet);
     packet.size = m_packet_size;
     packet.flow = this;
@@ -422,28 +422,29 @@ Packet TcpFlow::create_ack(Packet data) {
     ack.congestion_experienced = data.congestion_experienced;
 
     ack.flags = get_flag_manager();
-    auto result = ack.flags.set_flag(m_packet_type_label,
+    auto result = ack.flags.set_flag(
+        m_packet_type_label,
         (M_COLLECTIVE_ACK_SUPPORT ? PacketType::COLLECTIVE_ACK
                                   : PacketType::ACK));
     if (!result.has_value()) {
         LOG_ERROR(std::move(result.error()));
     }
-    
+
     result = ack.flags.set_flag(m_ack_ttl_label, data.ttl);
     if (!result.has_value()) {
         LOG_ERROR(std::move(result.error()));
     }
-        
+
     utils::StrExpected<TimeNs> exp_avg_rtt = get_avg_rtt_label(data.flags);
     if (!exp_avg_rtt.has_value()) {
         LOG_INFO(
             fmt::format("avg rtt flag does not set in data packet {} so it "
                         "will not be set in "
                         "ack {}",
-                         data.to_string(), ack.to_string()));
+                        data.to_string(), ack.to_string()));
         return ack;
-    } 
-        
+    }
+
     result = set_avg_rtt_flag(ack.flags, exp_avg_rtt.value());
     if (!result.has_value()) {
         // TODO: handle

source/device/hashers/adaptive_flowlet_hasher.cpp

@@ -35,13 +35,13 @@ std::uint32_t AdaptiveFlowletHasher::get_hash(const Packet& packet) {
 
     utils::StrExpected<TimeNs> exp_avg_rtt = get_avg_rtt_label(packet.flags);
     if (!exp_avg_rtt.has_value()) {
-        LOG_ERROR(fmt::format("Adaptive flowlet hasher could not find avg rtt ({});"
-                              "returned previous hash",
-                              exp_avg_rtt.error()));
+        LOG_ERROR(
+            fmt::format("Adaptive flowlet hasher could not find avg rtt ({});"
+                        "returned previous hash",
+                        exp_avg_rtt.error()));
         return ecmp_hash + shift;
     }
-    TimeNs flowlet_threshold =
-        exp_avg_rtt.value() * m_factor;
+    TimeNs flowlet_threshold = exp_avg_rtt.value() * m_factor;
 
     if (elapsed_from_last_seen > flowlet_threshold) {
         shift++;

source/utils/avg_rtt_packet_flag.hpp

@@ -19,13 +19,15 @@ inline bool register_packet_avg_rtt_flag(BaseFlagManager& flag_manager) {
                                                 sizeof_bits(AvgRttCastType));
 }
 
-[[nodiscard]] inline std::expected<void, std::string> set_avg_rtt_flag(BaseFlagManager& flag_manager, TimeNs rtt) {
+[[nodiscard]] inline std::expected<void, std::string> set_avg_rtt_flag(
+    BaseFlagManager& flag_manager, TimeNs rtt) {
     AvgRttCastType value = rtt.value_nanoseconds();
     AvgRttFlagType casted_value = std::bit_cast<AvgRttFlagType>(value);
     return flag_manager.set_flag(packet_avg_rtt_label, casted_value);
 }
 
-[[nodiscard]] inline utils::StrExpected<TimeNs> get_avg_rtt_label(const BaseFlagManager& flag_manager) {
+[[nodiscard]] inline utils::StrExpected<TimeNs> get_avg_rtt_label(
+    const BaseFlagManager& flag_manager) {
     auto exp_flag = flag_manager.get_flag(packet_avg_rtt_label);
     if (!exp_flag.has_value()) {
         return std::unexpected(exp_flag.error());

source/utils/flag_manager.hpp

@@ -63,10 +63,12 @@ class FlagManager {
         return true;
     }
 
-    [[nodiscard]] std::expected<void, std::string> set_flag(FlagId id, BitStorage value) {
+    [[nodiscard]] std::expected<void, std::string> set_flag(FlagId id,
+                                                            BitStorage value) {
         auto it = m_flag_manager.find(id);
         if (it == m_flag_manager.end()) {
-            return std::unexpected(fmt::format("Flag with id '{}' was not registred.", id));
+            return std::unexpected(
+                fmt::format("Flag with id '{}' was not registred.", id));
         }
 
         FlagInfo& info = it->second;
@@ -78,18 +80,18 @@ class FlagManager {
     [[nodiscard]] utils::StrExpected<BitStorage> get_flag(FlagId id) const {
         auto it = m_flag_manager.find(id);
         if (it == m_flag_manager.end()) {
-            return std::unexpected(fmt::format("Flag with id '{}' was not registred.", id));
+            return std::unexpected(
+                fmt::format("Flag with id '{}' was not registred.", id));
         }
         const FlagInfo& info = it->second;
         if (!info.is_set) {
-            return std::unexpected(fmt::format("Flag with id '{}' was not set.", id));
+            return std::unexpected(
+                fmt::format("Flag with id '{}' was not set.", id));
         }
         return m_bits.get_range(info.start, info.start + info.length - 1);
     }
 
-    BitSet<BitStorage> get_bit_storage() const {
-        return m_bits;
-    }
+    BitSet<BitStorage> get_bit_storage() const { return m_bits; }
 
     void reset() {
         m_next_pos = 0;