libcamera: bound_method: Propagate method return value

Propagate the return value of the bound method all the way to the caller
of activate(). The value is stored in the arguments pack for indirect
invocation.

As C++ doesn't allow instantiating a variable of type void, we need to
specialize the template class BoundMethodPack for methods returning
void. This in turn requires template specialization for the
BoundMethodArgs class in order to store the return value in the pack,
and for the BoundMemberMethod class to extract the return value from the
pack.

Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Reviewed-by: Niklas Söderlund <niklas.soderlund@ragnatech.se>

2 files changed, 24 insertions, 5 deletions

diff --git a/src/libcamera/bound_method.cpp b/src/libcamera/bound_method.cpp
index 82339b7e..8e95c7ee 100644
--- a/src/libcamera/bound_method.cpp
+++ b/src/libcamera/bound_method.cpp
@@ -48,7 +48,22 @@ namespace libcamera {
  * deadlock will occur.
  */
 
-void BoundMethodBase::activatePack(std::shared_ptr<BoundMethodPackBase> pack,
+/**
+ * \brief Invoke the bound method with packed arguments
+ * \param[in] pack Packed arguments
+ * \param[in] deleteMethod True to delete \a this bound method instance when
+ * method invocation completes
+ *
+ * The bound method stores its return value, if any, in the arguments \a pack.
+ * For direct and blocking invocations, this is performed synchronously, and
+ * the return value contained in the pack may be used. For queued invocations,
+ * the return value is stored at an undefined point of time and shall thus not
+ * be used by the caller.
+ *
+ * \return True if the return value contained in the \a pack may be used by the
+ * caller, false otherwise
+ */
+bool BoundMethodBase::activatePack(std::shared_ptr<BoundMethodPackBase> pack,
 				   bool deleteMethod)
 {
 	ConnectionType type = connectionType_;
@@ -65,13 +80,13 @@ void BoundMethodBase::activatePack(std::shared_ptr<BoundMethodPackBase> pack,
 		invokePack(pack.get());
 		if (deleteMethod)
 			delete this;
-		break;
+		return true;
 
 	case ConnectionTypeQueued: {
 		std::unique_ptr<Message> msg =
 			utils::make_unique<InvokeMessage>(this, pack, nullptr, deleteMethod);
 		object_->postMessage(std::move(msg));
-		break;
+		return false;
 	}
 
 	case ConnectionTypeBlocking: {
@@ -82,7 +97,7 @@ void BoundMethodBase::activatePack(std::shared_ptr<BoundMethodPackBase> pack,
 		object_->postMessage(std::move(msg));
 
 		semaphore.acquire();
-		break;
+		return true;
 	}
 	}
 }
diff --git a/src/libcamera/object.cpp b/src/libcamera/object.cpp
index e76faf48..21aad565 100644
--- a/src/libcamera/object.cpp
+++ b/src/libcamera/object.cpp
@@ -143,7 +143,7 @@ void Object::message(Message *msg)
 }
 
 /**
- * \fn void Object::invokeMethod()
+ * \fn R Object::invokeMethod()
  * \brief Invoke a method asynchronously on an Object instance
  * \param[in] func The object method to invoke
  * \param[in] type Connection type for method invocation
@@ -156,6 +156,10 @@ void Object::message(Message *msg)
  * Arguments \a args passed by value or reference are copied, while pointers
  * are passed untouched. The caller shall ensure that any pointer argument
  * remains valid until the method is invoked.
+ *
+ * \return For connection types ConnectionTypeDirect and
+ * ConnectionTypeBlocking, return the return value of the invoked method. For
+ * connection type ConnectionTypeQueued, return a default-constructed R value.
  */
 
 /**