Extend the ApiResponse type with optional payload (#1337)

Added `ExtendedResponse` and `ExtendedCallback` types that uses
`olp::client::NetworkStatistics` as a payload.
Enable the GetAggregatedData and QuadTreeIndex APIs to return the
extended responses.
Added NotFound, Unknown helper methods to `ApiError` class.
Fixed a warning in `BackdownStrategy` class.

Relates-To: OLPEDGE-2753

Signed-off-by: Mykhailo Kuchma <[email protected]>

Author: mykhailo-kuchma

olp-cpp-sdk-core/include/olp/core/client/ApiError.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2021 HERE Europe B.V.
+ * Copyright (C) 2019-2022 HERE Europe B.V.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -85,6 +85,30 @@ class CORE_API ApiError {
     return {ErrorCode::InvalidArgument, message};
   }
 
+  /**
+   * @brief Creates the `ApiError` instance with the not found error code and
+   * description.
+   *
+   * @param description The optional description.
+   *
+   * @return The `ApiError` instance.
+   */
+  static ApiError NotFound(const char* message = "Resource not found") {
+    return {ErrorCode::NotFound, message};
+  }
+
+  /**
+   * @brief Creates the `ApiError` instance with the unknown error code and
+   * description.
+   *
+   * @param description The optional description.
+   *
+   * @return The `ApiError` instance.
+   */
+  static ApiError Unknown(const char* message = "Unknown") {
+    return {ErrorCode::Unknown, message};
+  }
+
   ApiError() = default;
 
   /**

olp-cpp-sdk-core/include/olp/core/client/ApiResponse.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2021 HERE Europe B.V.
+ * Copyright (C) 2019-2022 HERE Europe B.V.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,13 +22,36 @@
 #include <future>
 #include <memory>
 #include <string>
+#include <type_traits>
 #include <utility>
 
 #include "CancellationToken.h"
 
 namespace olp {
 namespace client {
 
+/// The `ApiResponse` extension class, used to carry the payload with the
+/// response.
+template <typename Payload>
+class ResponseExtension {
+ public:
+  ResponseExtension() = default;
+
+  explicit ResponseExtension(Payload payload) : payload_(std::move(payload)) {}
+
+  const Payload& GetPayload() const { return payload_; }
+
+ protected:
+  Payload payload_{};
+};
+
+/// The `ApiResponse` extension class specialization without any payload.
+template <>
+class ResponseExtension<void> {
+ public:
+  ResponseExtension() = default;
+};
+
 /**
  * @brief Represents a request outcome.
  *
@@ -38,19 +61,78 @@ namespace client {
  * @tparam Result The result type.
  * @tparam Error The error type.
  */
-template <typename Result, typename Error>
-class ApiResponse {
+template <typename Result, typename Error, typename Payload = void>
+class ApiResponse : public ResponseExtension<Payload> {
  public:
+  /// The type of result.
+  using ResultType = Result;
+
+  /// The type of error.
+  using ErrorType = Error;
+
+  /// The type of additional payload.
+  using PayloadType = Payload;
+
+  ApiResponse() = default;
+
   /**
-   * @brief The type of result.
+   * @brief Creates the `ApiResponse` instance from a similar response type
+   * without payload. The payload is default initialized.
+   *
+   * @note Enabled only for the use cases when the input response type has no
+   * payload.
+   *
+   * Used for moving the successfully executed request.
+   *
+   * @param other The `ApiResponse` instance.
    */
-  using ResultType = Result;
+  template <typename P = Payload, typename = typename std::enable_if<
+                                      !std::is_same<P, void>::value>::type>
+  ApiResponse(const ApiResponse<Result, Error, void>& other)  // NOLINT
+      : ResponseExtension<P>(),
+        result_(other.GetResult()),
+        error_(other.GetError()),
+        success_(other.IsSuccessful()) {}
+
   /**
-   * @brief The type of error.
+   * @brief Creates the `ApiResponse` instance from a similar response type
+   * without payload, and a separate payload.
+   *
+   * @note Enabled only for the use cases when the input response type has no
+   * payload.
+   *
+   * Used for moving the successfully executed request.
+   *
+   * @param other The `ApiResponse` instance.
+   * @param payload The `Payload` value.
    */
-  using ErrorType = Error;
+  template <typename P = Payload, typename = typename std::enable_if<
+                                      !std::is_same<P, void>::value>::type>
+  ApiResponse(const ApiResponse<Result, Error, void>& other, P payload)
+      : ResponseExtension<P>(std::move(payload)),
+        result_(other.GetResult()),
+        error_(other.GetError()),
+        success_(other.IsSuccessful()) {}
 
-  ApiResponse() = default;
+  /**
+   * @brief Creates the `ApiResponse` instance from a similar request with a
+   * payload.
+   *
+   * @note Enabled only for the use cases when the input with a payload is
+   * sliced to the response without payload.
+   *
+   * Used for moving the successfully executed request.
+   *
+   * @param other The `ApiResponse` instance.
+   */
+  template <
+      typename U, typename P = Payload,
+      typename = typename std::enable_if<std::is_same<P, void>::value>::type>
+  ApiResponse(const ApiResponse<Result, Error, U>& other)
+      : ResponseExtension<P>(),
+        result_(other.GetResult()),
+        error_(other.GetError()),
+        success_(other.IsSuccessful()) {}
 
   /**
    * @brief Creates the `ApiResponse` instance.
@@ -60,7 +142,24 @@ class ApiResponse {
    * @param result The `ResultType` instance.
    */
   ApiResponse(ResultType result)  // NOLINT
-      : result_(std::move(result)), success_(true) {}
+      : ResponseExtension<Payload>(),
+        result_(std::move(result)),
+        success_(true) {}
+
+  /**
+   * @brief Creates the `ApiResponse` instance with payload.
+   *
+   * Used for moving the successfully executed request.
+   *
+   * @param result The `ResultType` instance.
+   * @param payload The payload.
+   */
+  template <typename P = Payload, typename = typename std::enable_if<
+                                      !std::is_same<P, void>::value>::type>
+  ApiResponse(ResultType result, P payload)
+      : ResponseExtension<Payload>(std::move(payload)),
+        result_(std::move(result)),
+        success_(true) {}
 
   /**
    * @brief Creates the `ApiResponse` instance if the request is not successful.
@@ -70,6 +169,18 @@ class ApiResponse {
   ApiResponse(const ErrorType& error)  // NOLINT
       : error_(error), success_(false) {}
 
+  /**
+   * @brief Creates the `ApiResponse` instance if the request is not successful.
+   *
+   * @param error The `ErrorType` instance.
+   */
+  template <typename P = Payload, typename = typename std::enable_if<
+                                      !std::is_same<P, void>::value>::type>
+  ApiResponse(const ErrorType& error, P payload)
+      : ResponseExtension<Payload>(std::move(payload)),
+        error_(error),
+        success_(false) {}
+
   /**
    * @brief Checks the status of the request attempt.
    *

olp-cpp-sdk-core/include/olp/core/client/BackdownStrategy.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020 HERE Europe B.V.
+ * Copyright (C) 2020-2022 HERE Europe B.V.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -105,7 +105,7 @@ struct CORE_API EqualJitterBackdownStrategy {
     constexpr size_t max_retry_count = 30u;
     retry_count = std::min<size_t>(retry_count, max_retry_count);
     const int64_t exponential_wait_time =
-        initial_backdown_period.count() * (1 << retry_count);
+        initial_backdown_period.count() * (1ull << retry_count);
     static thread_local std::mt19937 kGenerator(std::random_device{}());
     const auto temp = std::min<int64_t>(cap_.count(), exponential_wait_time);
     std::uniform_int_distribution<int64_t> dist(0, temp / 2);

olp-cpp-sdk-core/include/olp/core/client/HttpResponse.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2021 HERE Europe B.V.
+ * Copyright (C) 2019-2022 HERE Europe B.V.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -70,6 +70,13 @@ class NetworkStatistics {
     return *this;
   }
 
+  /// An overloaded addition operator for accumulating statistics.
+  NetworkStatistics operator+(const NetworkStatistics& other) const {
+    NetworkStatistics statistics(*this);
+    statistics += other;
+    return statistics;
+  }
+
  private:
   uint64_t bytes_uploaded_{0};
   uint64_t bytes_downloaded_{0};

olp-cpp-sdk-core/tests/CMakeLists.txt

@@ -1,4 +1,4 @@
-# Copyright (C) 2019-2021 HERE Europe B.V.
+# Copyright (C) 2019-2022 HERE Europe B.V.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -25,6 +25,7 @@ set(OLP_CPP_SDK_CORE_TESTS_SOURCES
     ./cache/ProtectedKeyListTest.cpp
 
     ./client/ApiLookupClientImplTest.cpp
+    ./client/ApiResponseTest.cpp
     ./client/BackdownStrategyTest.cpp
     ./client/CancellationContextTest.cpp
     ./client/ConditionTest.cpp

olp-cpp-sdk-core/tests/client/ApiResponseTest.cpp

@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2022 HERE Europe B.V.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * License-Filename: LICENSE
+ */
+
+#include <olp/core/client/ApiResponse.h>
+
+#include <gtest/gtest.h>
+
+namespace {
+
+struct PayloadT {
+  int v;
+};
+
+struct PrivateClass {
+  explicit PrivateClass(int v) : v_(v) {}
+  PrivateClass(const PrivateClass&) = delete;
+  PrivateClass(PrivateClass&&) = default;
+
+  int v_;
+};
+
+using ResultType = int;
+using ErrorType = std::string;
+
+using olp::client::ApiResponse;
+
+using IntResponse = ApiResponse<ResultType, ErrorType>;
+using ExtendedIntResponse = ApiResponse<ResultType, ErrorType, PayloadT>;
+
+inline bool operator==(const PayloadT& l, const PayloadT& r) {
+  return l.v == r.v;
+}
+
+TEST(ApiResponseTest, Payload) {
+  ExtendedIntResponse extended_response_1(1, PayloadT{2});
+  ExtendedIntResponse extended_response_2 = extended_response_1;
+  EXPECT_EQ(extended_response_1.GetPayload(), extended_response_2.GetPayload());
+  ExtendedIntResponse extended_response_3(IntResponse(2),
+                                          extended_response_2.GetPayload());
+  EXPECT_EQ(extended_response_1.GetPayload(), extended_response_3.GetPayload());
+}
+
+TEST(ApiResponseTest, ResponseSlicing) {
+  ExtendedIntResponse extended_response_1(1, PayloadT{2});
+
+  IntResponse sliced_response_1(extended_response_1);
+  EXPECT_EQ(sliced_response_1.GetResult(), 1);
+  EXPECT_EQ(sliced_response_1.IsSuccessful(),
+            extended_response_1.IsSuccessful());
+
+  IntResponse sliced_response_2 = extended_response_1;
+  EXPECT_EQ(sliced_response_2.GetResult(), 1);
+  EXPECT_EQ(sliced_response_2.IsSuccessful(),
+            extended_response_1.IsSuccessful());
+
+  ExtendedIntResponse extended_response_2("error", PayloadT{2});
+
+  IntResponse sliced_response_3(extended_response_2);
+  EXPECT_EQ(sliced_response_3.GetError(), "error");
+  EXPECT_EQ(sliced_response_3.IsSuccessful(),
+            extended_response_2.IsSuccessful());
+
+  IntResponse sliced_response_4 = extended_response_2;
+  EXPECT_EQ(sliced_response_4.GetError(), "error");
+  EXPECT_EQ(sliced_response_4.IsSuccessful(),
+            extended_response_2.IsSuccessful());
+}
+
+TEST(ApiResponseTest, ResponseExtention) {
+  IntResponse normal_response_1(123);
+
+  ExtendedIntResponse extended_response_1(normal_response_1);
+  EXPECT_EQ(extended_response_1.GetResult(), 123);
+  EXPECT_EQ(extended_response_1.IsSuccessful(),
+            normal_response_1.IsSuccessful());
+
+  ExtendedIntResponse extended_response_2 = normal_response_1;
+  EXPECT_EQ(extended_response_2.GetResult(), 123);
+  EXPECT_EQ(extended_response_2.IsSuccessful(),
+            normal_response_1.IsSuccessful());
+
+  ExtendedIntResponse extended_response_3(normal_response_1, PayloadT{234});
+  EXPECT_EQ(extended_response_3.GetResult(), 123);
+  EXPECT_EQ(extended_response_3.GetPayload(), PayloadT{234});
+
+  IntResponse normal_response_2("error");
+
+  ExtendedIntResponse extended_response_4(normal_response_2);
+  EXPECT_EQ(extended_response_4.GetError(), "error");
+  EXPECT_EQ(extended_response_4.IsSuccessful(),
+            normal_response_2.IsSuccessful());
+
+  ExtendedIntResponse extended_response_5 = normal_response_2;
+  EXPECT_EQ(extended_response_5.GetError(), "error");
+  EXPECT_EQ(extended_response_5.IsSuccessful(),
+            normal_response_2.IsSuccessful());
+
+  ExtendedIntResponse extended_response_6(normal_response_2, PayloadT{234});
+  EXPECT_EQ(extended_response_6.GetError(), "error");
+  EXPECT_EQ(extended_response_6.GetPayload(), PayloadT{234});
+}
+
+TEST(ApiResponseTest, ResultWithoutCopyCtor) {
+  using ProvateResponse = ApiResponse<PrivateClass, ErrorType, PayloadT>;
+  // move constructed
+  ProvateResponse response_1(PrivateClass(1));
+  // move asigned
+  ProvateResponse response_2 = PrivateClass(1);
+  // response can be moved
+  ProvateResponse response_3 = std::move(response_2);
+}
+}  // namespace