Flow measure descriptions

include/ECFMP/flowmeasure/AirportFilter.h

@@ -30,5 +30,10 @@ namespace ECFMP::FlowMeasure {
          * Returns the type of airport filter
          */
         [[nodiscard]] virtual auto Type() const noexcept -> AirportFilterType = 0;
+
+        /**
+         * Returns a string representation of the filter.
+         */
+        [[nodiscard]] virtual auto FilterDescription() const noexcept -> std::string = 0;
     };
 }// namespace ECFMP::FlowMeasure

include/ECFMP/flowmeasure/EventFilter.h

@@ -43,5 +43,10 @@ namespace ECFMP::FlowMeasure {
          * Returns true if the event participation is "Participating in"
          */
         [[nodiscard]] virtual auto IsParticipating() const noexcept -> bool = 0;
+
+        /**
+         * Returns a description of the filter.
+         */
+        [[nodiscard]] virtual auto FilterDescription() const noexcept -> std::string = 0;
     };
 }// namespace ECFMP::FlowMeasure

include/ECFMP/flowmeasure/FlowMeasureFilters.h

@@ -71,5 +71,10 @@ namespace ECFMP::FlowMeasure {
         [[nodiscard]] virtual auto
         FirstRangeToDestinationFilter(const std::function<bool(const RangeToDestinationFilter&)>& callback
         ) const noexcept -> std::shared_ptr<RangeToDestinationFilter> = 0;
+
+        /**
+         * Convenience method to return string description of the filters.
+         */
+        [[nodiscard]] virtual auto FilterDescriptions() const noexcept -> std::vector<std::string> = 0;
     };
 }// namespace ECFMP::FlowMeasure

include/ECFMP/flowmeasure/LevelRangeFilter.h

@@ -41,5 +41,10 @@ namespace ECFMP::FlowMeasure {
          * Helper method to determine, given a particular altitude (e.g. 35000), does this filter apply.
          */
         [[nodiscard]] virtual auto ApplicableToAltitude(int level) const noexcept -> bool = 0;
+
+        /**
+         * Description of the filter.
+         */
+        [[nodiscard]] virtual auto FilterDescription() const noexcept -> std::string = 0;
     };
 }// namespace ECFMP::FlowMeasure

include/ECFMP/flowmeasure/Measure.h

@@ -73,5 +73,10 @@ namespace ECFMP::FlowMeasure {
          * Throws an IllegalFlowMeasureValueException exception otherwise.
          */
         [[nodiscard]] virtual auto SetValue() const -> const std::set<std::string>& = 0;
+
+        /**
+         * Returns a string representation of the measure.
+         */
+        [[nodiscard]] virtual auto MeasureDescription() const noexcept -> std::string = 0;
     };
 }// namespace ECFMP::FlowMeasure

include/ECFMP/flowmeasure/MultipleLevelFilter.h

@@ -29,5 +29,10 @@ namespace ECFMP::FlowMeasure {
          * Helper method to determine, given a particular altitude (e.g. 35000), does this filter apply.
          */
         [[nodiscard]] virtual auto ApplicableToAltitude(int level) const noexcept -> bool = 0;
+
+        /**
+         * Description of the filter
+         */
+        [[nodiscard]] virtual auto FilterDescription() const noexcept -> std::string = 0;
     };
 }// namespace ECFMP::FlowMeasure

include/ECFMP/flowmeasure/RangeToDestinationFilter.h

@@ -8,11 +8,16 @@ namespace ECFMP::FlowMeasure {
     class RangeToDestinationFilter : public ChecksAircraftApplicability
     {
         public:
-        virtual ~RangeToDestinationFilter() = default;
+        ~RangeToDestinationFilter() override = default;
 
         /**
          * Returns the range to destination.
          */
         [[nodiscard]] virtual auto Range() const noexcept -> int = 0;
+
+        /**
+         * Description of the filter
+         */
+        [[nodiscard]] virtual auto FilterDescription() const noexcept -> std::string = 0;
     };
 }// namespace ECFMP::FlowMeasure

include/ECFMP/flowmeasure/RouteFilter.h

@@ -9,6 +9,16 @@ namespace ECFMP::FlowMeasure {
     {
         public:
         virtual ~RouteFilter() = default;
+
+        /**
+         * Returns the set of route strings that this filter pertains to.
+         * @return
+         */
         [[nodiscard]] virtual auto RouteStrings() const noexcept -> const std::set<std::string>& = 0;
+
+        /**
+         * Description of the filter.
+         */
+        [[nodiscard]] virtual auto FilterDescription() const noexcept -> std::string = 0;
     };
 }// namespace ECFMP::FlowMeasure

include/mock/AirportFilterMock.h

@@ -11,6 +11,7 @@ namespace ECFMP::Mock::FlowMeasure {
         MOCK_METHOD(ECFMP::FlowMeasure::AirportFilterType, Type, (), (const, noexcept, override));
         MOCK_METHOD(bool, ApplicableToAirport, (const std::string&), (const, noexcept, override));
         MOCK_METHOD(bool, ApplicableToAircraft, (const Euroscope::EuroscopeAircraft&), (const, noexcept, override));
+        MOCK_METHOD(std::string, FilterDescription, (), (const, noexcept, override));
     };
 
 }// namespace ECFMP::Mock::FlowMeasure

include/mock/EventFilterMock.h

@@ -12,6 +12,7 @@ namespace ECFMP::Mock::FlowMeasure {
         MOCK_METHOD(ECFMP::FlowMeasure::EventParticipation, Participation, (), (const, noexcept, override));
         MOCK_METHOD(bool, IsParticipating, (), (const, noexcept, override));
         MOCK_METHOD(bool, ApplicableToAircraft, (const Euroscope::EuroscopeAircraft&), (const, noexcept, override));
+        MOCK_METHOD(std::string, FilterDescription, (), (const, noexcept, override));
     };
 
 }// namespace ECFMP::Mock::FlowMeasure

include/mock/FlowMeasureFiltersMock.h

@@ -65,6 +65,7 @@ namespace ECFMP::Mock::FlowMeasure {
                 (const std::function<bool(const ECFMP::FlowMeasure::RangeToDestinationFilter&)>&),
                 (const, noexcept, override)
         );
+        MOCK_METHOD(std::vector<std::string>, FilterDescriptions, (), (const, noexcept, override));
     };
 
 }// namespace ECFMP::Mock::FlowMeasure

include/mock/LevelRangeFilterMock.h

@@ -13,6 +13,7 @@ namespace ECFMP::Mock::FlowMeasure {
         MOCK_METHOD(bool, ApplicableToAltitude, (int), (const, noexcept, override));
         MOCK_METHOD(bool, ApplicableToLevel, (int), (const, noexcept, override));
         MOCK_METHOD(bool, ApplicableToAircraft, (const Euroscope::EuroscopeAircraft&), (const, noexcept, override));
+        MOCK_METHOD(std::string, FilterDescription, (), (const, noexcept, override));
     };
 
 }// namespace ECFMP::Mock::FlowMeasure

include/mock/MeasureMock.h

@@ -11,6 +11,7 @@ namespace ECFMP::Mock::FlowMeasure {
         MOCK_METHOD(int, IntegerValue, (), (const, override));
         MOCK_METHOD(double, DoubleValue, (), (const, override));
         MOCK_METHOD(const std::set<std::string>&, SetValue, (), (const, override));
+        MOCK_METHOD(std::string, MeasureDescription, (), (const, noexcept, override));
     };
 
 }// namespace ECFMP::Mock::FlowMeasure

include/mock/MultipleLevelFilterMock.h

@@ -12,6 +12,7 @@ namespace ECFMP::Mock::FlowMeasure {
         MOCK_METHOD(bool, ApplicableToAltitude, (int), (const, noexcept, override));
         MOCK_METHOD(bool, ApplicableToLevel, (int), (const, noexcept, override));
         MOCK_METHOD(bool, ApplicableToAircraft, (const Euroscope::EuroscopeAircraft&), (const, noexcept, override));
+        MOCK_METHOD(std::string, FilterDescription, (), (const, noexcept, override));
     };
 
 }// namespace ECFMP::Mock::FlowMeasure

include/mock/RangeToDestinationFilterMock.h

@@ -10,5 +10,6 @@ namespace ECFMP::Mock::FlowMeasure {
                 bool, ApplicableToAircraft, (const ECFMP::Euroscope::EuroscopeAircraft&), (const, noexcept, override)
         );
         MOCK_METHOD(int, Range, (), (const, noexcept, override));
+        MOCK_METHOD(std::string, FilterDescription, (), (const, noexcept, override));
     };
 }// namespace ECFMP::Mock::FlowMeasure

include/mock/RouteFilterMock.h

@@ -9,6 +9,7 @@ namespace ECFMP::Mock::FlowMeasure {
         public:
         MOCK_METHOD(const std::set<std::string>&, RouteStrings, (), (const, noexcept, override));
         MOCK_METHOD(bool, ApplicableToAircraft, (const Euroscope::EuroscopeAircraft&), (const, noexcept, override));
+        MOCK_METHOD(std::string, FilterDescription, (), (const, noexcept, override));
     };
 
 }// namespace ECFMP::Mock::FlowMeasure

src/flowmeasure/ConcreteAirportFilter.cpp

@@ -39,4 +39,18 @@ namespace ECFMP::FlowMeasure {
                 type == AirportFilterType::Departure ? aircraft.DepartureAirport() : aircraft.DestinationAirport()
         );
     }
+
+    std::string ConcreteAirportFilter::FilterDescription() const noexcept
+    {
+        std::string description = type == AirportFilterType::Departure ? "Departing: " : "Arriving: ";
+
+        for (const auto& airportString: airportStrings) {
+            const auto isWildcard = airportString.find(WILDCARD_CHAR) != std::string::npos;
+            description += isWildcard ? "Any of: " + airportString : airportString;
+            description += ", ";
+        }
+
+        // Trim the trailing ", "
+        return description.substr(0, description.length() - 2);
+    }
 }// namespace ECFMP::FlowMeasure

src/flowmeasure/ConcreteAirportFilter.h

@@ -10,7 +10,9 @@ namespace ECFMP::FlowMeasure {
         [[nodiscard]] auto AirportStrings() const noexcept -> const std::set<std::string>& override;
         [[nodiscard]] auto ApplicableToAirport(const std::string& airport) const noexcept -> bool override;
         [[nodiscard]] auto Type() const noexcept -> AirportFilterType override;
-        auto ApplicableToAircraft(const Euroscope::EuroscopeAircraft& aircraft) const noexcept -> bool override;
+        [[nodiscard]] auto ApplicableToAircraft(const Euroscope::EuroscopeAircraft& aircraft) const noexcept
+                -> bool override;
+        [[nodiscard]] auto FilterDescription() const noexcept -> std::string override;
 
         private:
         // The strings for the airport filter, may contain wildcards (*)

src/flowmeasure/ConcreteEventFilter.cpp

@@ -60,4 +60,9 @@ namespace ECFMP::FlowMeasure {
 
         return (IsParticipating() && isParticipating) || (!IsParticipating() && !isParticipating);
     }
+
+    auto ConcreteEventFilter::FilterDescription() const noexcept -> std::string
+    {
+        return (IsParticipating() ? "Participating in event: " : "Not participating in event: ") + event->Name();
+    }
 }// namespace ECFMP::FlowMeasure

src/flowmeasure/ConcreteEventFilter.h

@@ -18,6 +18,7 @@ namespace ECFMP::FlowMeasure {
         [[nodiscard]] auto Participation() const noexcept -> EventParticipation override;
         [[nodiscard]] auto IsParticipating() const noexcept -> bool override;
         auto ApplicableToAircraft(const Euroscope::EuroscopeAircraft& aircraft) const noexcept -> bool override;
+        [[nodiscard]] auto FilterDescription() const noexcept -> std::string override;
 
         private:
         // The event in question

src/flowmeasure/ConcreteFlowMeasureFilters.cpp

@@ -251,4 +251,52 @@ namespace ECFMP::FlowMeasure {
 
         return passesRangeToDestinationFilters;
     }
+
+    auto ConcreteFlowMeasureFilters::FilterDescriptions() const noexcept -> std::vector<std::string>
+    {
+        std::vector<std::string> descriptions;
+        descriptions.reserve(
+                airportFilters.size() + eventFilters.size() + levelFilters.size() + multipleLevelFilters.size()
+                + routeFilters.size() + rangeToDestinationFilters.size()
+        );
+
+        std::transform(
+                airportFilters.cbegin(), airportFilters.cend(), std::back_inserter(descriptions),
+                [](const auto& filter) {
+                    return filter->FilterDescription();
+                }
+        );
+        std::transform(
+                eventFilters.cbegin(), eventFilters.cend(), std::back_inserter(descriptions),
+                [](const auto& filter) {
+                    return filter->FilterDescription();
+                }
+        );
+        std::transform(
+                levelFilters.cbegin(), levelFilters.cend(), std::back_inserter(descriptions),
+                [](const auto& filter) {
+                    return filter->FilterDescription();
+                }
+        );
+        std::transform(
+                multipleLevelFilters.cbegin(), multipleLevelFilters.cend(), std::back_inserter(descriptions),
+                [](const auto& filter) {
+                    return filter->FilterDescription();
+                }
+        );
+        std::transform(
+                routeFilters.cbegin(), routeFilters.cend(), std::back_inserter(descriptions),
+                [](const auto& filter) {
+                    return filter->FilterDescription();
+                }
+        );
+        std::transform(
+                rangeToDestinationFilters.cbegin(), rangeToDestinationFilters.cend(), std::back_inserter(descriptions),
+                [](const auto& filter) {
+                    return filter->FilterDescription();
+                }
+        );
+
+        return descriptions;
+    }
 }// namespace ECFMP::FlowMeasure

src/flowmeasure/ConcreteFlowMeasureFilters.h

@@ -59,6 +59,7 @@ namespace ECFMP::FlowMeasure {
         [[nodiscard]] auto
         FirstRangeToDestinationFilter(const std::function<bool(const RangeToDestinationFilter&)>& callback
         ) const noexcept -> std::shared_ptr<RangeToDestinationFilter> override;
+        [[nodiscard]] auto FilterDescriptions() const noexcept -> std::vector<std::string> override;
 
         private:
         // All the airport filters

src/flowmeasure/ConcreteLevelRangeFilter.cpp

@@ -36,4 +36,10 @@ namespace ECFMP::FlowMeasure {
     {
         return ApplicableToAltitude(aircraft.CruiseAltitude());
     }
+
+    auto ConcreteLevelRangeFilter::FilterDescription() const noexcept -> std::string
+    {
+        return type == LevelRangeFilterType::AtOrBelow ? "At or below: FL" + std::to_string(filterLevel)
+                                                       : "At or above: FL" + std::to_string(filterLevel);
+    }
 }// namespace ECFMP::FlowMeasure

src/flowmeasure/ConcreteLevelRangeFilter.h

@@ -13,6 +13,7 @@ namespace ECFMP::FlowMeasure {
         [[nodiscard]] auto ApplicableToLevel(int level) const noexcept -> bool override;
         [[nodiscard]] auto ApplicableToAltitude(int level) const noexcept -> bool override;
         auto ApplicableToAircraft(const Euroscope::EuroscopeAircraft& aircraft) const noexcept -> bool override;
+        [[nodiscard]] auto FilterDescription() const noexcept -> std::string override;
 
         private:
         // The type of level filter this is

src/flowmeasure/ConcreteMeasure.cpp

@@ -1,4 +1,7 @@
 #include "ConcreteMeasure.h"
+#include "ECFMP/flowmeasure/Measure.h"
+#include <stdexcept>
+#include <string>
 
 namespace ECFMP::FlowMeasure {
 
@@ -49,4 +52,89 @@ namespace ECFMP::FlowMeasure {
             throw IllegalFlowMeasureValueException();
         }
     }
+
+    auto ConcreteMeasure::MeasureDescription() const noexcept -> std::string
+    {
+        // No value type associated with these
+        if (type == MeasureType::GroundStop || type == MeasureType::Prohibit) {
+            return MeasureTypeToString(type);
+        }
+
+        return MeasureTypeToString(type) + ": " + MeasureValueToString(type);
+    }
+
+    auto ConcreteMeasure::MeasureTypeToString(MeasureType type) -> std::string
+    {
+        switch (type) {
+        case MeasureType::MinimumDepartureInterval:
+            return "Minimum Departure Interval";
+        case MeasureType::AverageDepartureInterval:
+            return "Average Departure Interval";
+        case MeasureType::PerHour:
+            return "Per Hour";
+        case MeasureType::MilesInTrail:
+            return "Miles in Trail";
+        case MeasureType::MaxIndicatedAirspeed:
+            return "Max IAS";
+        case MeasureType::IndicatedAirspeedReduction:
+            return "IAS Reduction";
+        case MeasureType::MaxMach:
+            return "Max Mach";
+        case MeasureType::MachReduction:
+            return "Mach Reduction";
+        case MeasureType::MandatoryRoute:
+            return "Mandatory Route(s)";
+        case MeasureType::Prohibit:
+            return "Prohibit";
+        case MeasureType::GroundStop:
+            return "Ground Stop";
+        default:
+            return "Unknown";
+        }
+    }
+
+    auto ConcreteMeasure::MeasureValueToString(MeasureType measureType) const -> std::string
+    {
+        switch (measureType) {
+        case MeasureType::MinimumDepartureInterval:
+        case MeasureType::AverageDepartureInterval: {
+            const auto extraSeconds = intValue % 60;
+            const auto minutes = intValue / 60;
+
+            if (minutes == 0) {
+                return std::to_string(extraSeconds) + " seconds";
+            }
+
+            if (extraSeconds == 0) {
+                return std::to_string(minutes) + " minutes";
+            }
+
+            return std::to_string(minutes) + " minutes " + std::to_string(extraSeconds) + " seconds";
+        }
+        case MeasureType::PerHour:
+        case MeasureType::MilesInTrail:
+            return std::to_string(intValue);
+        case MeasureType::MaxIndicatedAirspeed:
+        case MeasureType::IndicatedAirspeedReduction:
+            return std::to_string(intValue) + "kts";
+        case MeasureType::MaxMach:
+        case MeasureType::MachReduction: {
+            std::stringstream stream;
+            stream << std::fixed << std::setprecision(2) << doubleValue;
+            return stream.str();
+        }
+        case MeasureType::MandatoryRoute: {
+            std::string routeString;
+            for (const auto& route: setValue) {
+                routeString += route + ", ";
+            }
+            return routeString.substr(0, routeString.size() - 2);
+        }
+        case MeasureType::Prohibit:
+        case MeasureType::GroundStop:
+            throw std::logic_error("MeasureType::Prohibit and MeasureType::GroundStop have no value");
+        }
+
+        return "Unknown";
+    }
 }// namespace ECFMP::FlowMeasure