Repo created

2025-11-22 13:58:55 +01:00 · 2025-11-22 13:58:55 +01:00 · 68073add76
commit 68073add76
parent 4af19165ec
12458 changed files with 12350765 additions and 2 deletions
--- a/libs/routing/road_penalty_serialization.hpp
+++ b/libs/routing/road_penalty_serialization.hpp
@ -0,0 +1,110 @@
+#pragma once
+
+#include "routing/road_penalty.hpp"
+#include "routing/road_point.hpp"
+
+#include "coding/reader.hpp"
+#include "coding/write_to_sink.hpp"
+
+#include "base/assert.hpp"
+
+#include <cstdint>
+#include <vector>
+
+namespace routing
+{
+class RoadPenaltySerializer final
+{
+public:
+  using PointToPenalty = RoadPenalty::PointToPenalty;
+  using Penalty = RoadPenalty::Penalty;
+
+  RoadPenaltySerializer() = delete;
+
+  template <typename Sink>
+  static void Serialize(Sink & sink, RoadPenalty const & roadPenalty)
+  {
+    SerializePenalties(sink, roadPenalty.GetPointToPenalty());
+  }
+
+  template <typename Source>
+  static void Deserialize(Source & src, RoadPenalty & roadPenalty, VehicleType vehicleType)
+  {
+    PointToPenalty pointToPenalty;
+    DeserializePenalties(src, pointToPenalty, vehicleType);
+
+    roadPenalty.SetPointPenalties(std::move(pointToPenalty));
+  }
+
+private:
+  template <typename Sink>
+  static void SerializePenalty(Sink & sink, Penalty const & penalty)
+  {
+    WriteToSink(sink, static_cast<uint8_t>(penalty.m_type));
+    // Time is derived from type + vehicle when loading
+  }
+
+  template <typename Source>
+  static void DeserializePenalty(Source & src, Penalty & penalty, VehicleType vehicleType)
+  {
+    penalty.m_type = static_cast<RoadPenalty::Type>(ReadPrimitiveFromSource<uint8_t>(src));
+    penalty.m_timeSeconds = Penalty::GetTimePenalty(penalty.m_type, vehicleType);
+  }
+
+  template <typename Sink, typename PenaltyMap>
+  static void SerializePenalties(Sink & sink, PenaltyMap const & penalties)
+  {
+    WriteToSink(sink, static_cast<uint32_t>(penalties.size()));
+    for (auto const & [key, penalty] : penalties)
+    {
+      SerializeKey(sink, key);
+      SerializePenalty(sink, penalty);
+    }
+  }
+
+  template <typename Source, typename PenaltyMap>
+  static void DeserializePenalties(Source & src, PenaltyMap & penalties, VehicleType vehicleType)
+  {
+    uint32_t const size = ReadPrimitiveFromSource<uint32_t>(src);
+    penalties.reserve(size);
+
+    for (uint32_t i = 0; i < size; ++i)
+    {
+      typename PenaltyMap::key_type key;
+      DeserializeKey(src, key);
+
+      Penalty penalty;
+      DeserializePenalty(src, penalty, vehicleType);
+
+      penalties[key] = penalty;
+    }
+  }
+
+  template <typename Sink>
+  static void SerializeKey(Sink & sink, uint32_t key)
+  {
+    WriteToSink(sink, key);
+  }
+
+  template <typename Source>
+  static void DeserializeKey(Source & src, uint32_t & key)
+  {
+    key = ReadPrimitiveFromSource<uint32_t>(src);
+  }
+
+  template <typename Sink>
+  static void SerializeKey(Sink & sink, RoadPoint const & key)
+  {
+    WriteToSink(sink, key.GetFeatureId());
+    WriteToSink(sink, key.GetPointId());
+  }
+
+  template <typename Source>
+  static void DeserializeKey(Source & src, RoadPoint & key)
+  {
+    uint32_t featureId = ReadPrimitiveFromSource<uint32_t>(src);
+    uint32_t pointId = ReadPrimitiveFromSource<uint32_t>(src);
+    key = RoadPoint(featureId, pointId);
+  }
+};
+}  // namespace routing