Add more precise interface handleTimeoutMicroseconds

lcm/lcm-cpp-impl.hpp

@@ -215,6 +215,15 @@ inline int LCM::handleTimeout(int timeout_millis)
     return lcm_handle_timeout(this->lcm, timeout_millis);
 }
 
+inline int LCM::handleTimeoutUs(int timeout_micros)
+{
+    if (!this->lcm) {
+        fprintf(stderr, "LCM instance not initialized.  Ignoring call to handle()\n");
+        return -1;
+    }
+    return lcm_handle_timeout_us(this->lcm, timeout_micros);
+}
+
 template <class MessageType, class MessageHandlerClass>
 Subscription *LCM::subscribe(const std::string &channel,
                              void (MessageHandlerClass::*handlerMethod)(const ReceiveBuffer *rbuf,

lcm/lcm-cpp.hpp

@@ -142,6 +142,17 @@ class LCM {
      */
     inline int handleTimeout(int timeout_millis);
 
+    /**
+     * @brief Waits for and dispatches messages, with a timeout.
+     *
+     * New in LCM 1.1.0.
+     *
+     * @return >0 if a message was handled, 0 if the function timed out,
+     * and <0 if an error occured.
+     * @sa lcm_handle_timeout_us()
+     */
+    inline int handleTimeoutUs(int timeout_micros);
+
     /**
      * @brief Subscribes a callback method of an object to a channel, with
      * automatic message decoding.

lcm/lcm.c

@@ -237,6 +237,32 @@ int lcm_handle_timeout(lcm_t *lcm, int timeout_milis)
     }
 }
 
+int lcm_handle_timeout_us(lcm_t *lcm, int timeout_micros)
+{
+    fd_set fds;
+    FD_ZERO(&fds);
+    SOCKET lcm_fd = lcm_get_fileno(lcm);
+    FD_SET(lcm_fd, &fds);
+
+    struct timeval timeout;
+    timeout.tv_sec = timeout_micros / 1000000;
+    timeout.tv_usec = timeout_micros % 1000000;
+
+    if (timeout_micros < 0) {
+        return -1;
+    }
+
+    int select_result = select(lcm_fd + 1, &fds, NULL, NULL, &timeout);
+    if (select_result > 0) {
+        int lcm_handle_result = lcm_handle(lcm);
+        return lcm_handle_result == 0 ? 1 : lcm_handle_result;
+    } else if (select_result == 0) {
+        return 0;
+    } else {
+        return select_result;
+    }
+}
+
 int lcm_get_fileno(lcm_t *lcm)
 {
     if (lcm->provider && lcm->vtable->get_fileno)

lcm/lcm.h

@@ -322,6 +322,30 @@ int lcm_handle(lcm_t *lcm);
 LCM_EXPORT
 int lcm_handle_timeout(lcm_t *lcm, int timeout_millis);
 
+/**
+ * @brief Wait for and dispatch the next incoming message, up to a time limit.
+ *
+ * This function is equivalent to lcm_handle(), but if no messages are received
+ * and handled by the time @p timeout_micros microseconds elapses, then the
+ * function returns.
+ *
+ * This function largely exists for convenience, and its behavior can be
+ * replicated by using lcm_fileno() and lcm_handle() in conjunction with
+ * select() or poll().
+ *
+ * New in LCM 1.1.0.
+ *
+ * @param lcm the %LCM object
+ * @param timeout_micros the maximum amount of time to wait for a message, in
+ *        microseconds.  If 0, then dispatches any available messages and then
+ *        returns immediately.  Values less than 0 are not allowed.
+ *
+ * @return >0 if a message was handled, 0 if the function timed out, and <0 if
+ * an error occured.
+ */
+LCM_EXPORT
+int lcm_handle_timeout_us(lcm_t *lcm, int timeout_micros);
+
 /**
  * @brief Adjusts the maximum number of received messages that can be queued up
  * for a subscription.

test/cpp/memq_test.cpp

@@ -99,6 +99,15 @@ TEST(LCM_CPP, MemqTimeout)
     // Invalid timeout specification should result in an error.
     EXPECT_GT(0, lcm.handleTimeout(-1));
 
+    // No messages available.  Call should timeout immediately.
+    EXPECT_EQ(0, lcm.handleTimeoutUs(0));
+
+    // No messages available.  Call should timeout in a few ms.
+    EXPECT_EQ(0, lcm.handleTimeoutUs(10));
+
+    // Invalid timeout specification should result in an error.
+    EXPECT_GT(0, lcm.handleTimeoutUs(-1));
+
     // Subscribe to and publish on a channel.  Expect that the message gets
     // handled with an ample timeout.
     bool msg_handled = false;