Improvements from wiper hackathon (eclipse-velocitas#4)

* Improvements from wiper hackathon
* Update NOTICE-3RD-PARTY-CONTENT.md

Co-authored-by: Dominic Sudy <[email protected]>

Author: BjoernAtBosch

.github/workflows/ci.yml

@@ -73,12 +73,16 @@ jobs:
           indicators: true
           output: both
 
-      - name: Add Coverage PR Comment
-        uses: marocchino/sticky-pull-request-comment@v2
-        if: github.event_name == 'pull_request'
-        with:
-          recreate: true
-          path: code-coverage-results.md
+      #########################################################
+      # This step was disabled temporarily due to the required
+      # write access rights of the PRs for external contributors.
+      #########################################################
+      #- name: Add Coverage PR Comment
+      #  uses: marocchino/sticky-pull-request-comment@v2
+      #  if: github.event_name == 'pull_request'
+      #  with:
+      #    recreate: true
+      #    path: code-coverage-results.md
 
       - name: Run Linters
         uses: pre-commit/[email protected]

NOTICE-3RD-PARTY-CONTENT.md

@@ -55,6 +55,5 @@
 |EnricoMi/publish-unit-test-result-action|v1|Apache License 2.0|
 |fusion-engineering/setup-git-credentials|v2|BSD 2-Clause "Simplified" License|
 |irongut/CodeCoverageSummary|v1.2.0|MIT License|
-|marocchino/sticky-pull-request-comment|v2|MIT License|
 |pre-commit/action|v3.0.0|MIT License|
 |softprops/action-gh-release|v1|MIT License|

sdk/include/sdk/AsyncResult.h

@@ -163,6 +163,25 @@ template <typename TResultType> class AsyncResult {
      */
     [[nodiscard]] bool isInAwaitingState() const { return m_awaiting; }
 
+    /**
+     * @brief Map the result to a different type using the provided mapper function.
+     *
+     * @tparam TNewType    The new type created by the mapper function.
+     * @param mapper       The mapper function to convert TResultType to TNewType.
+     * @return std::shared_ptr<AsyncResult<TNewType>>
+     *                     A new AsyncResult object which emits results of TNewType.
+     */
+    template <typename TNewType>
+    std::shared_ptr<AsyncResult<TNewType>> map(std::function<TNewType(const TResultType&)> mapper) {
+        auto mappedResult = std::make_shared<AsyncResult<TNewType>>();
+
+        onResult([mappedResult, mapper](auto item) { mappedResult->insertResult(mapper(item)); });
+
+        onError([mappedResult](auto status) { mappedResult->insertError(std::move(status)); });
+
+        return mappedResult;
+    }
+
 private:
     TResultType      m_result;
     ResultCallback_t m_callback;

sdk/include/sdk/DataPoint.h

@@ -134,6 +134,8 @@ class DataPointBoolean : public DataPoint {
 public:
     using DataPoint::DataPoint;
 
+    using value_type = bool;
+
     ~DataPointBoolean() override = default;
 
     DataPointBoolean(const DataPointBoolean&)            = delete;
@@ -154,6 +156,8 @@ class DataPointBooleanArray : public DataPoint {
 public:
     using DataPoint::DataPoint;
 
+    using value_type = std::vector<bool>;
+
     ~DataPointBooleanArray() override = default;
 
     DataPointBooleanArray(const DataPointBooleanArray&)            = delete;
@@ -174,6 +178,8 @@ class DataPointInt32 : public DataPoint {
 public:
     using DataPoint::DataPoint;
 
+    using value_type = int32_t;
+
     ~DataPointInt32() override = default;
 
     DataPointInt32(const DataPointInt32&)            = delete;
@@ -194,6 +200,8 @@ class DataPointInt32Array : public DataPoint {
 public:
     using DataPoint::DataPoint;
 
+    using value_type = std::vector<int32_t>;
+
     ~DataPointInt32Array() override = default;
 
     DataPointInt32Array(const DataPointInt32Array&)            = delete;
@@ -216,6 +224,8 @@ class DataPointInt64 : public DataPoint {
 public:
     using DataPoint::DataPoint;
 
+    using value_type = int64_t;
+
     ~DataPointInt64() override = default;
 
     DataPointInt64(const DataPointInt64&)            = delete;
@@ -236,6 +246,8 @@ class DataPointInt64Array : public DataPoint {
 public:
     using DataPoint::DataPoint;
 
+    using value_type = std::vector<int64_t>;
+
     ~DataPointInt64Array() override = default;
 
     DataPointInt64Array(const DataPointInt64Array&)            = delete;
@@ -258,6 +270,8 @@ class DataPointUint32 : public DataPoint {
 public:
     using DataPoint::DataPoint;
 
+    using value_type = uint32_t;
+
     ~DataPointUint32() override = default;
 
     DataPointUint32(const DataPointUint32&)            = delete;
@@ -278,6 +292,8 @@ class DataPointUint32Array : public DataPoint {
 public:
     using DataPoint::DataPoint;
 
+    using value_type = std::vector<uint32_t>;
+
     ~DataPointUint32Array() override = default;
 
     DataPointUint32Array(const DataPointUint32Array&)            = delete;
@@ -300,6 +316,8 @@ class DataPointUint64 : public DataPoint {
 public:
     using DataPoint::DataPoint;
 
+    using value_type = uint64_t;
+
     ~DataPointUint64() override = default;
 
     DataPointUint64(const DataPointUint64&)            = delete;
@@ -320,6 +338,8 @@ class DataPointUint64Array : public DataPoint {
 public:
     using DataPoint::DataPoint;
 
+    using value_type = std::vector<uint64_t>;
+
     ~DataPointUint64Array() override = default;
 
     DataPointUint64Array(const DataPointUint64Array&)            = delete;
@@ -342,6 +362,8 @@ class DataPointFloat : public DataPoint {
 public:
     using DataPoint::DataPoint;
 
+    using value_type = float;
+
     ~DataPointFloat() override = default;
 
     DataPointFloat(const DataPointFloat&)            = delete;
@@ -362,6 +384,8 @@ class DataPointFloatArray : public DataPoint {
 public:
     using DataPoint::DataPoint;
 
+    using value_type = std::vector<float>;
+
     ~DataPointFloatArray() override = default;
 
     DataPointFloatArray(const DataPointFloatArray&)            = delete;
@@ -384,6 +408,8 @@ class DataPointDouble : public DataPoint {
 public:
     using DataPoint::DataPoint;
 
+    using value_type = double;
+
     ~DataPointDouble() override = default;
 
     DataPointDouble(const DataPointDouble&)            = delete;
@@ -404,6 +430,8 @@ class DataPointDoubleArray : public DataPoint {
 public:
     using DataPoint::DataPoint;
 
+    using value_type = std::vector<double>;
+
     ~DataPointDoubleArray() override = default;
 
     DataPointDoubleArray(const DataPointDoubleArray&)            = delete;
@@ -426,6 +454,8 @@ class DataPointString : public DataPoint {
 public:
     using DataPoint::DataPoint;
 
+    using value_type = std::string;
+
     ~DataPointString() override = default;
 
     DataPointString(const DataPointString&)            = delete;
@@ -446,6 +476,8 @@ class DataPointStringArray : public DataPoint {
 public:
     using DataPoint::DataPoint;
 
+    using value_type = std::vector<std::string>;
+
     ~DataPointStringArray() override = default;
 
     DataPointStringArray(const DataPointStringArray&)            = delete;

sdk/include/sdk/DataPointsResult.h

@@ -17,6 +17,10 @@
 #ifndef VEHICLE_APP_SDK_DATAPOINTSRESULT_H
 #define VEHICLE_APP_SDK_DATAPOINTSRESULT_H
 
+#include "sdk/Exceptions.h"
+
+#include <fmt/core.h>
+
 #include <map>
 #include <string>
 
@@ -49,17 +53,22 @@ class DataPointsResult final {
     [[nodiscard]] std::shared_ptr<TDataPointType> get(const TDataPointType& dataPoint) const {
         static_assert(std::is_base_of_v<DataPoint, TDataPointType>);
 
+        if (m_dataPointsMap.find(dataPoint.getPath()) == m_dataPointsMap.end()) {
+            throw InvalidValueException(
+                fmt::format("{} is not contained in result!", dataPoint.getPath()));
+        }
+
         auto result = m_dataPointsMap.at(dataPoint.getPath());
         return std::dynamic_pointer_cast<TDataPointType>(result);
     }
 
-  /**
-   * @brief Check if the result is empty.
-   *
-   * @return true   Result is empty.
-   * @return false  Result is not empty.
-   */
-  bool empty() { return m_dataPointsMap.empty(); }
+    /**
+     * @brief Check if the result is empty.
+     *
+     * @return true   Result is empty.
+     * @return false  Result is not empty.
+     */
+    bool empty() { return m_dataPointsMap.empty(); }
 
 private:
     DataPointMap_t m_dataPointsMap;

sdk/include/sdk/VehicleApp.h

@@ -97,12 +97,27 @@ class VehicleApp {
      * @brief Get values for all provided data points from the data broker.
      *
      * @param dataPoints    Vector of data points to obtain values for.
-     * @return AsyncResultPtr_t<DataPointsResult>  The result that contains data point results for
-     * all requested data points.
+     * @return AsyncResultPtr_t<DataPointsResult>  The result containing the data point
+     *     results for all requested data points.
      */
     AsyncResultPtr_t<DataPointsResult>
     getDataPoints(const std::vector<std::reference_wrapper<DataPoint>>& dataPoints);
 
+    /**
+     * @brief Get the value a certain data point from the data broker.
+     *
+     * @param dataPoint    The data point to obtain values for.
+     * @return AsyncResultPtr_t<typename TDataPoint::value_type>  The result containing
+     *     the data point result of the requested data point.
+     */
+    template <typename TDataPoint>
+    AsyncResultPtr_t<typename TDataPoint::value_type> getDataPoint(const TDataPoint& dataPoint) const {
+        return getDataPoint_internal(dataPoint)->template map<typename TDataPoint::value_type>(
+            [&dataPoint](const DataPointsResult& dataPointsResult) {
+                return dataPointsResult.get<TDataPoint>(dataPoint)->value();
+            });
+    }
+
     /**
      * @brief Subscribes to the query string for data points.
      *
@@ -126,6 +141,9 @@ class VehicleApp {
     std::shared_ptr<IPubSubClient> getPubSubClient();
 
 private:
+    [[nodiscard]] AsyncResultPtr_t<DataPointsResult>
+    getDataPoint_internal(const DataPoint& dataPoint) const;
+
     std::shared_ptr<IVehicleDataBrokerClient> m_vdbClient;
     std::shared_ptr<IPubSubClient>            m_pubSubClient;
 };

sdk/src/sdk/VehicleApp.cpp

@@ -70,6 +70,14 @@ VehicleApp::getDataPoints(const std::vector<std::reference_wrapper<DataPoint>>&
     return m_vdbClient->getDatapoints(dataPointPaths);
 }
 
+AsyncResultPtr_t<DataPointsResult>
+VehicleApp::getDataPoint_internal(const DataPoint& dataPoint) const {
+    std::vector<std::string> dataPointPaths;
+    dataPointPaths.reserve(1);
+    dataPointPaths.emplace_back(dataPoint.getPath());
+    return m_vdbClient->getDatapoints(dataPointPaths);
+}
+
 AsyncSubscriptionPtr_t<DataPointsResult> VehicleApp::subscribeDataPoints(const std::string& query) {
     return m_vdbClient->subscribe(query);
 }