Add custom std::formatters for many classes (#307)

* Add custom formatters for `Agent` and `Street` classes

* Add custom formatter also for `TrafficLight`-related classes

Author: Grufoony

src/dsf/dsf.hpp

@@ -6,7 +6,7 @@
 
 static constexpr uint8_t DSF_VERSION_MAJOR = 3;
 static constexpr uint8_t DSF_VERSION_MINOR = 1;
-static constexpr uint8_t DSF_VERSION_PATCH = 0;
+static constexpr uint8_t DSF_VERSION_PATCH = 1;
 
 static auto const DSF_VERSION =
     std::format("{}.{}.{}", DSF_VERSION_MAJOR, DSF_VERSION_MINOR, DSF_VERSION_PATCH);

src/dsf/headers/Agent.hpp

@@ -16,9 +16,11 @@
 
 #include <cassert>
 #include <concepts>
+#include <format>
 #include <limits>
 #include <optional>
 #include <stdexcept>
+#include <string>
 #include <vector>
 
 namespace dsf {
@@ -118,3 +120,24 @@ namespace dsf {
     bool isRandom() const;
   };
 };  // namespace dsf
+
+template <>
+struct std::formatter<dsf::Agent> {
+  constexpr auto parse(std::format_parse_context& ctx) { return ctx.begin(); }
+  template <typename FormatContext>
+  auto format(const dsf::Agent& agent, FormatContext& ctx) const {
+    auto const strItinerary = agent.trip().empty() ? std::string("RANDOM")
+                                                   : std::to_string(agent.itineraryId());
+    return std::format_to(ctx.out(),
+                          "Agent (srcNode {} - it {}) spawn time {} - free time {}: {} "
+                          "-> {} ({} m/s - {} m)",
+                          agent.srcNodeId().value_or(-1),
+                          strItinerary,
+                          agent.spawnTime(),
+                          agent.freeTime(),
+                          agent.streetId().value_or(-1),
+                          agent.nextStreetId().value_or(-1),
+                          agent.speed(),
+                          agent.distance());
+  }
+};

src/dsf/headers/RoadDynamics.hpp

@@ -94,7 +94,7 @@ namespace dsf {
     /// @brief Evolve the agents.
     /// @details Puts all new agents on a street, if possible, decrements all delays
     /// and increments all travel times.
-    void m_evolveAgent(std::unique_ptr<Agent> const& pAgent);
+    // void m_evolveAgent(std::unique_ptr<Agent> const& pAgent);
 
     void m_trafficlightSingleTailOptimizer(double const& beta,
                                            std::optional<std::ofstream>& logStream);
@@ -614,8 +614,8 @@ namespace dsf {
     }
 
     if (possibleMoves.empty()) {
-      throw std::runtime_error(std::format(
-          "No possible moves for agent {} at node {}.", pAgent->id(), nodeId));
+      throw std::runtime_error(
+          std::format("No possible moves for agent {} at node {}.", *pAgent, nodeId));
     }
 
     if (possibleMoves.size() == 1) {
@@ -743,21 +743,15 @@ namespace dsf {
           auto const timeDiff{this->time() - pAgentTemp->freeTime()};
           if (timeDiff > 120) {
             overtimed = true;
-            Logger::warning(std::format(
-                "Time {} - Agent ({} -> {}) currently on {} ({} -> {}), targetting {} "
-                "({} turn - "
-                "Traffic "
-                "Light? {}), has been still for more than 120 seconds ({} seconds)",
-                this->time(),
-                pAgentTemp->srcNodeId().value_or(-1),
-                this->m_itineraries.at(pAgentTemp->itineraryId())->destination(),
-                pStreet->id(),
-                pStreet->source(),
-                pStreet->target(),
-                pAgentTemp->nextStreetId().value_or(-1),
-                directionToString.at(pStreet->laneMapping().at(queueIndex)),
-                this->graph().node(pStreet->target())->isTrafficLight(),
-                timeDiff));
+            Logger::warning(
+                std::format("Time {} - {} currently on {} ({} turn - Traffic Light? {}), "
+                            "has been still for more than 120 seconds ({} seconds)",
+                            this->time(),
+                            *pAgentTemp,
+                            *pStreet,
+                            directionToString.at(pStreet->laneMapping().at(queueIndex)),
+                            this->graph().node(pStreet->target())->isTrafficLight(),
+                            timeDiff));
           }
         }
         pAgentTemp->setSpeed(0.);
@@ -946,27 +940,24 @@ namespace dsf {
           continue;
         }
         if (!pAgentTemp->streetId().has_value()) {
-          Logger::error(std::format("Agent {} has no street id", pAgentTemp->id()));
+          Logger::error(std::format("{} has no street id", *pAgentTemp));
         }
         auto const& nextStreet{this->graph().edge(pAgentTemp->nextStreetId().value())};
         if (nextStreet->isFull()) {
           if (overtimed) {
-            Logger::warning(std::format(
-                "Skipping agent emission from street {} -> {} due to full next street "
-                "{} - strId {} ({}/{})",
-                pStreet->source(),
-                pStreet->target(),
-                nextStreet->id(),
-                nextStreet->strId().value_or("None"),
-                nextStreet->nAgents(),
-                nextStreet->capacity()));
+            Logger::warning(
+                std::format("Skipping agent emission from street {} -> {} due to full "
+                            "next street: {}",
+                            pStreet->source(),
+                            pStreet->target(),
+                            *nextStreet));
           } else {
-            Logger::debug(std::format(
-                "Skipping agent emission from street {} -> {} due to full next street "
-                "{}",
-                pStreet->source(),
-                pStreet->target(),
-                nextStreet->id()));
+            Logger::debug(
+                std::format("Skipping agent emission from street {} -> {} due to full "
+                            "next street: {}",
+                            pStreet->source(),
+                            pStreet->target(),
+                            *nextStreet));
           }
           continue;
         }
@@ -1012,7 +1003,7 @@ namespace dsf {
           auto& pAgent{it->second};
           auto const& nextStreet{this->graph().edge(pAgent->nextStreetId().value())};
           if (nextStreet->isFull()) {
-            Logger::debug(std::format("Next street {} is full", nextStreet->id()));
+            Logger::debug(std::format("Next street is full: {}", *nextStreet));
             if (m_forcePriorities) {
               Logger::debug(
                   std::format("Forcing priority from intersection {} on street {}",
@@ -1029,12 +1020,11 @@ namespace dsf {
                               std::ceil(nextStreet->length() / pAgent->speed()));
           Logger::debug(std::format(
               "An agent at time {} has been dequeued from intersection {} and "
-              "enqueued on street {} with speed {} and free time {}",
+              "enqueued on street {}: {}",
               this->time(),
               pNode->id(),
               nextStreet->id(),
-              pAgent->speed(),
-              pAgent->freeTime()));
+              *pAgent));
           nextStreet->addAgent(std::move(pAgent));
           it = intersection.agents().erase(it);
           break;
@@ -1064,12 +1054,11 @@ namespace dsf {
                               std::ceil(nextStreet->length() / pAgent->speed()));
           Logger::debug(
               std::format("An agent at time {} has been dequeued from roundabout {} and "
-                          "enqueued on street {} with speed {} and free time {}",
+                          "enqueued on street {}: {}",
                           this->time(),
                           pNode->id(),
                           nextStreet->id(),
-                          pAgent->speed(),
-                          pAgent->freeTime()));
+                          *pAgent));
           nextStreet->addAgent(std::move(pAgent));
         } else {
           return;
@@ -1078,11 +1067,11 @@ namespace dsf {
     }
   }
 
-  template <typename delay_t>
-    requires(is_numeric_v<delay_t>)
-  void RoadDynamics<delay_t>::m_evolveAgent(std::unique_ptr<Agent> const& pAgent) {
-    // The "cost" of enqueuing is one time unit, so we consider it as passed
-  }
+  // template <typename delay_t>
+  //   requires(is_numeric_v<delay_t>)
+  // void RoadDynamics<delay_t>::m_evolveAgent(std::unique_ptr<Agent> const& pAgent) {
+  //   // The "cost" of enqueuing is one time unit, so we consider it as passed
+  // }
 
   template <typename delay_t>
     requires(is_numeric_v<delay_t>)
@@ -1512,11 +1501,8 @@ namespace dsf {
           this->graph().edge(pAgent->nextStreetId().value())};  // next street
       if (nextStreet->isFull()) {
         ++itAgent;
-        Logger::debug(
-            std::format("Skipping agent {} on node {} due to full initial street {}",
-                        pAgent->id(),
-                        srcNode->id(),
-                        nextStreet->id()));
+        Logger::debug(std::format(
+            "Skipping agent {} due to full input street {}", *pAgent, *nextStreet));
         continue;
       }
       assert(srcNode->id() == nextStreet->source());
@@ -1872,12 +1858,11 @@ namespace dsf {
                   direction == Direction::RIGHTANDSTRAIGHT) {
                 auto const& pStreet{this->graph().edge(streetId)};
                 if (logStream.has_value()) {
-                  *logStream << std::format("\tFree cycle ({}) for {} -> {}: {} {}\n",
-                                            directionToString[direction],
+                  *logStream << std::format("\tFree cycle for {} -> {}: dir {} - {}\n",
                                             pStreet->source(),
                                             pStreet->target(),
-                                            freecycle.greenTime(),
-                                            freecycle.phase());
+                                            directionToString[direction],
+                                            freecycle);
                 }
                 cycle = freecycle;
               }
@@ -1908,21 +1893,7 @@ namespace dsf {
 
       tl.setCycles(cycles);
       if (logStream.has_value()) {
-        std::string logMsg =
-            std::format("\tNew cycles for TL {} ({}):\n", tl.id(), tl.cycleTime());
-        for (auto const& [streetId, pair] : tl.cycles()) {
-          auto const& pStreet{this->graph().edge(streetId)};
-          logMsg +=
-              std::format("\t\tStreet {} -> {}: ", pStreet->source(), pStreet->target());
-          for (auto const& [direction, cycle] : pair) {
-            logMsg += std::format("{}= ({} {}) ",
-                                  directionToString[direction],
-                                  cycle.greenTime(),
-                                  cycle.phase());
-          }
-          logMsg += '\n';
-        }
-        *logStream << logMsg << '\n';
+        *logStream << std::format("\nNew cycles for {}", tl);
       }
     }
     if (logStream.has_value()) {
@@ -1995,21 +1966,7 @@ namespace dsf {
                             (pStreet->maxSpeed() * (1. - 0.6 * pStreet->density(true))));
           optimizedNodes.insert(sourceId);
           if (logStream.has_value()) {
-            std::string logMsg =
-                std::format("\tNew cycles for TL {} ({}):\n", tl.id(), tl.cycleTime());
-            for (auto const& [streetId, pair] : tl.cycles()) {
-              auto const& pStreet{this->graph().edge(streetId)};
-              logMsg += std::format(
-                  "\t\tStreet {} -> {}: ", pStreet->source(), pStreet->target());
-              for (auto const& [direction, cycle] : pair) {
-                logMsg += std::format("{}= ({} {}) ",
-                                      directionToString[direction],
-                                      cycle.greenTime(),
-                                      cycle.phase());
-              }
-              logMsg += '\n';
-            }
-            *logStream << logMsg << '\n';
+            *logStream << std::format("\nNew cycles for {}", tl);
           }
         }
       }

src/dsf/headers/Street.hpp

@@ -216,3 +216,23 @@ namespace dsf {
   };
 
 };  // namespace dsf
+
+template <>
+struct std::formatter<dsf::Street> {
+  constexpr auto parse(std::format_parse_context& ctx) { return ctx.begin(); }
+  template <typename fmtContext>
+  auto format(const dsf::Street& street, fmtContext& ctx) const {
+    return std::format_to(
+        ctx.out(),
+        "Street \"{}\" ({}: {} -> {}). {} m - {} m/s - {} lanes - {} agents ({} exiting)",
+        street.name(),
+        street.id(),
+        street.nodePair().first,
+        street.nodePair().second,
+        street.length(),
+        street.maxSpeed(),
+        street.nLanes(),
+        street.nAgents(),
+        street.nExitingAgents());
+  }
+};

src/dsf/headers/TrafficLight.hpp

@@ -10,6 +10,10 @@
 #pragma once
 
 #include "Intersection.hpp"
+#include "../utility/Typedef.hpp"
+
+#include <format>
+#include <string>
 
 namespace dsf {
   class TrafficLightCycle {
@@ -143,6 +147,7 @@ namespace dsf {
     cycles() const {
       return m_cycles;
     }
+    inline Delay counter() const { return m_counter; }
     /// @brief Returns true if all the cycles are set to their default values
     bool isDefault() const;
     /// @brief Returns true if the traffic light is green for a street and a direction
@@ -159,4 +164,41 @@ namespace dsf {
     void resetCycles();
     inline bool isTrafficLight() const noexcept { return true; }
   };
-}  // namespace dsf
+}  // namespace dsf
+
+template <>
+struct std::formatter<dsf::TrafficLightCycle> {
+  constexpr auto parse(std::format_parse_context& ctx) { return ctx.begin(); }
+  template <typename FormatContext>
+  auto format(const dsf::TrafficLightCycle& cycle, FormatContext& ctx) const {
+    return std::format_to(ctx.out(),
+                          "TrafficLightCycle (green time: {} - phase shift: {})",
+                          cycle.greenTime(),
+                          cycle.phase());
+  }
+};
+
+template <>
+struct std::formatter<dsf::TrafficLight> {
+  constexpr auto parse(std::format_parse_context& ctx) { return ctx.begin(); }
+  template <typename FormatContext>
+  auto format(const dsf::TrafficLight& tl, FormatContext& ctx) const {
+    std::string strCycles;
+    for (auto const& [streetId, cycles] : tl.cycles()) {
+      std::string strStreetCycles{std::format("\tStreet {}:\n", streetId)};
+      for (auto const& [direction, cycle] : cycles) {
+        strStreetCycles += std::format(
+            "\t\t- dir {}: {}\n", dsf::directionToString.at(direction), cycle);
+      }
+      strCycles += strStreetCycles;
+    }
+    return std::format_to(
+        ctx.out(),
+        "TrafficLight \"{}\" ({}): cycle time {} - counter {}. Cycles:\n{}",
+        tl.name(),
+        tl.id(),
+        tl.cycleTime(),
+        tl.counter(),
+        strCycles);
+  }
+};

src/dsf/sources/Agent.cpp

@@ -1,5 +1,7 @@
 #include "../headers/Agent.hpp"
 
+#include <format>
+
 namespace dsf {
   Agent::Agent(Time const& spawnTime,
                std::optional<Id> itineraryId,
@@ -82,4 +84,4 @@ namespace dsf {
   double Agent::speed() const { return m_speed; }
   double Agent::distance() const { return m_distance; }
   bool Agent::isRandom() const { return m_trip.empty(); }
-}  // namespace dsf
+}  // namespace dsf

src/dsf/utility/Logger.hpp

@@ -9,10 +9,10 @@
 #include <string>
 #include <set>
 
-static std::string buildMessage(const std::string& type,
-                                const std::string& message,
-                                const std::source_location& location,
-                                bool verbose) {
+static inline std::string buildMessage(const std::string& type,
+                                       const std::string& message,
+                                       const std::source_location& location,
+                                       bool verbose) {
   if (verbose) {
     return std::format("{} ({}:{}) \'{}\': {}",
                        type,