merged changed into project branch

Author: =

README.md

@@ -78,6 +78,36 @@ cd build/Debug
 cmake --build . -- -j
 ```
 
+### With Conan for QNX
+
+Before building **up-cpp** we need to build all dependencies from **up-conan-recipes**:
+
+Please follow instruction for QNX build in file [up-conan-recipes/README.md](https://github.com/eclipse-uprotocol/up-conan-recipes/blob/main/README.md)
+
+Pre-requisite:
+
+* Build and install all **QNX build** dependencies from up-conan-recipes
+  - https://github.com/eclipse-uprotocol/up-conan-recipes
+
+```bash
+# setup path to up-conan-recipes
+export QNX_CONAN_ROOT=<path_to_up-conan-recipes>
+
+# Install conan toolchain for QNX target
+#
+# <profile-name>: nto-7.1-aarch64-le, nto-7.1-x86_64, nto-8.0-aarch64-le, nto-8.0-x86_64
+# <version-number>: 1.0.0-rc0, 1.0.0, 1.0.1-rc1, 1.0.1
+#
+conan install -pr:h=$QNX_CONAN_ROOT/tools/profiles/<profile-name> --version=<version-number> --build=missing .
+
+cmake --preset conan-release
+
+cmake --build build/Release -- -j
+
+# all tests you can find under build/Release/bin/
+# copy test binaries to your QNX target
+```
+
 ### Generate UT Coverage
 
 To get code coverage, perform the steps above, but replace `cmake --preset...` with

conanfile.py

@@ -0,0 +1,32 @@
+from conan import ConanFile
+from conan.tools.cmake import CMakeToolchain, cmake_layout, CMakeDeps
+
+class upCoreApiRecipe(ConanFile):
+    name = "up-cpp"
+
+    # Optional metadata
+    license = "Apache-2.0"
+    author = "Contributors to the Eclipse Foundation <[email protected]>"
+    url = "https://github.com/eclipse-uprotocol/up-cpp"
+    description = "This library provides a C++ uProtocol API for the development of uEntities"
+    topics = ("automotive", "iot", "uprotocol", "messaging")
+
+    # Binary configuration
+    settings = "os", "compiler", "build_type", "arch"
+
+    def requirements(self):
+        self.requires("protobuf/3.21.12")
+        self.requires("spdlog/1.13.0")
+        self.requires("up-core-api/[~1.6, include_prerelease]")
+        self.test_requires("gtest/1.14.0")
+
+    def layout(self):
+        cmake_layout(self)
+
+    def generate(self):
+        deps = CMakeDeps(self)
+        deps.generate()
+        tc = CMakeToolchain(self)
+        #all warnings have to be fixed
+        tc.cache_variables["CMAKE_CXX_FLAGS_INIT"] = "-Wno-error=unused-but-set-variable -Wno-error=pedantic -Wno-error=conversion"
+        tc.generate()

conanfile.txt

@@ -125,19 +125,7 @@ struct RpcClientUSubscription : USubscription {
 
 private:
 	std::shared_ptr<transport::UTransport> transport_;
-	// Currently a single RpcClient can only send messages to a fixed UUri.
-	// This forces us to use different RpcClients for different resource ids.
-	// The alternative would be to create a new RpcClient for each request and
-	// return a pointer to the client together with the InvokeProtoFuture to
-	// keep it alive
-	std::shared_ptr<communication::RpcClient> subscribe_client_;
-	std::shared_ptr<communication::RpcClient> unsubscribe_client_;
-	std::shared_ptr<communication::RpcClient> fetch_subscriptions_client_;
-	std::shared_ptr<communication::RpcClient> fetch_subscribers_client_;
-	std::shared_ptr<communication::RpcClient> register_for_notification_client_;
-	std::shared_ptr<communication::RpcClient>
-	    unregister_for_notification_client_;
-
+	std::shared_ptr<communication::RpcClient> rpc_client_;
 	USubscriptionUUriBuilder uuri_builder_;
 };
 

include/up-cpp/client/usubscription/v3/RpcClientUSubscription.h

@@ -54,8 +54,7 @@ struct RpcClient {
 	/// For guidance on the permeission_level and token parameters, see:
 	/// https://github.com/eclipse-uprotocol/up-spec/blob/main/basics/permissions.adoc
 	explicit RpcClient(std::shared_ptr<transport::UTransport> transport,
-	                   v1::UUri&& method, v1::UPriority priority,
-	                   std::chrono::milliseconds ttl,
+	                   v1::UPriority priority, std::chrono::milliseconds ttl,
 	                   std::optional<v1::UPayloadFormat> payload_format = {},
 	                   std::optional<uint32_t> permission_level = {},
 	                   std::optional<std::string> token = {});
@@ -113,6 +112,7 @@ struct RpcClient {
 
 	/// @brief Invokes an RPC method by sending a request message.
 	///
+	/// @param The method that will be invoked
 	/// @param A Payload builder containing the payload to be sent with the
 	///        request.
 	/// @param A callback that will be called with the result.
@@ -124,11 +124,13 @@ struct RpcClient {
 	///       * A UStatus based on the commstatus received in the response
 	///         message (if not OK).
 	///       * A UMessage containing the response from the RPC target.
-	[[nodiscard]] InvokeHandle invokeMethod(datamodel::builder::Payload&&,
+	[[nodiscard]] InvokeHandle invokeMethod(const v1::UUri&,
+	                                        datamodel::builder::Payload&&,
 	                                        Callback&&);
 
 	/// @brief Invokes an RPC method by sending a request message.
 	///
+	/// @param The method that will be invoked
 	/// @param A Payload builder containing the payload to be sent with the
 	///        request.
 	///
@@ -141,13 +143,15 @@ struct RpcClient {
 	///          * A UStatus based on the commstatus received in the response
 	///            message (if not OK).
 	///          * A UMessage containing the response from the RPC target.
-	[[nodiscard]] InvokeFuture invokeMethod(datamodel::builder::Payload&&);
+	[[nodiscard]] InvokeFuture invokeMethod(const v1::UUri&,
+	                                        datamodel::builder::Payload&&);
 
 	/// @brief Invokes an RPC method by sending a request message.
 	///
 	/// Request is sent with an empty payload. Can only be called if no payload
 	/// format was provided at construction time.
 	///
+	/// @param The method that will be invoked
 	/// @param A callback that will be called with the result.
 	///
 	/// @post The provided callback will be called with one of:
@@ -157,13 +161,14 @@ struct RpcClient {
 	///       * A UStatus based on the commstatus received in the response
 	///         message (if not OK).
 	///       * A UMessage containing the response from the RPC target.
-	[[nodiscard]] InvokeHandle invokeMethod(Callback&&);
+	[[nodiscard]] InvokeHandle invokeMethod(const v1::UUri&, Callback&&);
 
 	/// @brief Invokes an RPC method by sending a request message.
 	///
 	/// Request is sent with an empty payload. Can only be called if no payload
 	/// format was provided at construction time.
 	///
+	/// @param The method that will be invoked
 	/// @remarks This is a wrapper around the callback form of invokeMethod.
 	///
 	/// @returns A promised future that can resolve to one of:
@@ -173,7 +178,83 @@ struct RpcClient {
 	///          * A UStatus based on the commstatus received in the response
 	///            message (if not OK).
 	///          * A UMessage containing the response from the RPC target.
-	[[nodiscard]] InvokeFuture invokeMethod();
+	[[nodiscard]] InvokeFuture invokeMethod(const v1::UUri&);
+
+	template <typename R>
+	InvokeHandle invokeMethodToProto(const v1::UUri& method,
+	                                 const R& request_message,
+	                                 Callback&& callback) {
+		auto payload_or_status =
+		    uprotocol::utils::ProtoConverter::protoToPayload(request_message);
+
+		if (!payload_or_status.has_value()) {
+			return {};
+		}
+
+		datamodel::builder::Payload tmp_payload(payload_or_status.value());
+		auto handle = invokeMethod(
+		    builder_.withMethod(method).build(std::move(tmp_payload)),
+		    std::move(callback));
+
+		return handle;
+	}
+
+	template <typename T, typename R>
+	InvokeProtoFuture<T> invokeMethodToProto(const v1::UUri& method,
+	                                         const R& request_message) {
+		auto result_promise =
+		    std::make_shared<std::promise<ResponseOrStatus<T>>>();
+		auto future = result_promise->get_future();
+		auto handle = invokeMethodToProto(
+		    method, request_message,
+		    [result_promise](const MessageOrStatus& message_or_status) {
+			    if (!message_or_status.has_value()) {
+				    result_promise->set_value(ResponseOrStatus<T>(
+				        UnexpectedStatus(message_or_status.error())));
+				    return;
+			    }
+			    auto response_or_status =
+			        utils::ProtoConverter::extractFromProtobuf<T>(
+			            message_or_status.value());
+
+			    if (!response_or_status.has_value()) {
+				    spdlog::error(
+				        "invokeProtoMethod: Error when extracting response "
+				        "from "
+				        "protobuf.");
+				    result_promise->set_value(response_or_status);
+				    return;
+			    }
+
+			    result_promise->set_value(
+			        ResponseOrStatus<T>(response_or_status.value()));
+		    });
+
+		return {std::move(future), std::move(handle)};
+	}
+
+	template <typename R>
+	InvokeFuture invokeMethodToProto(const v1::UUri& method,
+	                                 const R& request_message) {
+		auto result_promise =
+		    std::make_shared<std::promise<ResponseOrStatus<v1::UMessage>>>();
+		auto future = result_promise->get_future();
+
+		auto handle = invokeMethodToProto(
+		    method, request_message,
+		    [result_promise](const MessageOrStatus& message_or_status) {
+			    if (!message_or_status.has_value()) {
+				    result_promise->set_value(ResponseOrStatus<v1::UMessage>(
+				        UnexpectedStatus(message_or_status.error())));
+				    return;
+			    }
+
+			    result_promise->set_value(
+			        ResponseOrStatus<v1::UMessage>(message_or_status.value()));
+		    });
+
+		return {std::move(future), std::move(handle)};
+	}
 
 	template <typename R>
 	InvokeHandle invokeProtoMethod(const R& request_message,

include/up-cpp/communication/RpcClient.h

@@ -23,8 +23,13 @@
 #include <string>
 #include <vector>
 
+#include "up-cpp/communication/NotificationSink.h"
 #include "up-cpp/datamodel/builder/Uuid.h"
 
+namespace uprotocol::communication {
+struct RpcClient;
+}
+
 namespace uprotocol::datamodel::builder {
 
 /// @brief Interface for composing UMessage objects
@@ -38,6 +43,7 @@ namespace uprotocol::datamodel::builder {
 ///          instance can be held and reused by calling .build(payload)
 ///          for each new set of message data.
 struct UMessageBuilder {
+	friend struct communication::RpcClient;
 	/// @brief Pre-populates a message builder with the attributes of a
 	///        "publish" type message.
 	///
@@ -103,6 +109,15 @@ struct UMessageBuilder {
 	/// @returns UMessageBuilder configured to build a "response" message
 	static UMessageBuilder response(const v1::UMessage& request);
 
+	/// @brief Set the method attribute for built messages.
+	///
+	/// @param The method to use when building messages.
+	///
+	/// @throws std::out_of_range if the value is not a valid method UUri
+	///
+	/// @returns A reference to this UMessageBuilder
+	UMessageBuilder& withMethod(const v1::UUri&);
+
 	/// @brief Set the message priority attribute for built messages.
 	///
 	/// If not called, the default value as specified in

include/up-cpp/datamodel/builder/UMessage.h

@@ -94,8 +94,7 @@ v1::UStatus Consumer::subscribe(
     v1::UPriority priority, std::chrono::milliseconds subscription_request_ttl,
     ListenCallback&& callback) {
 	rpc_client_ = std::make_unique<communication::RpcClient>(
-	    transport_, uSubscriptionUUriBuilder_.getServiceUriWithResourceId(1),
-	    priority, subscription_request_ttl);
+	    transport_, priority, subscription_request_ttl);
 
 	auto on_response = [this](const auto& maybe_response) {
 		if (maybe_response.has_value() &&
@@ -113,8 +112,9 @@ v1::UStatus Consumer::subscribe(
 	SubscriptionRequest const subscription_request = buildSubscriptionRequest();
 	auto payload = datamodel::builder::Payload(subscription_request);
 
-	rpc_handle_ =
-	    rpc_client_->invokeMethod(std::move(payload), std::move(on_response));
+	rpc_handle_ = rpc_client_->invokeMethod(
+	    uSubscriptionUUriBuilder_.getServiceUriWithResourceId(1),
+	    std::move(payload), std::move(on_response));
 
 	// Create a L2 subscription
 	auto result = communication::Subscriber::subscribe(
@@ -138,8 +138,7 @@ UnsubscribeRequest Consumer::buildUnsubscriptionRequest() {
 void Consumer::unsubscribe(v1::UPriority priority,
                            std::chrono::milliseconds request_ttl) {
 	rpc_client_ = std::make_unique<communication::RpcClient>(
-	    transport_, uSubscriptionUUriBuilder_.getServiceUriWithResourceId(2),
-	    priority, request_ttl);
+	    transport_, priority, request_ttl);
 
 	auto on_response = [](const auto& maybe_response) {
 		if (!maybe_response.has_value()) {
@@ -150,8 +149,9 @@ void Consumer::unsubscribe(v1::UPriority priority,
 	UnsubscribeRequest const unsubscribe_request = buildUnsubscriptionRequest();
 	auto payload = datamodel::builder::Payload(unsubscribe_request);
 
-	rpc_handle_ =
-	    rpc_client_->invokeMethod(std::move(payload), std::move(on_response));
+	rpc_handle_ = rpc_client_->invokeMethod(
+	    uSubscriptionUUriBuilder_.getServiceUriWithResourceId(2),
+	    std::move(payload), std::move(on_response));
 
 	subscriber_.reset();
 }