pingmessage: [performance] break parser logic into a state-indexed tuple of callbacks

Swaps up to 11 conditionals per byte with a consistent single tuple index and function call.

Author: ES-Alexander

brping/pingmessage.py

@@ -294,84 +294,115 @@ class PingParser(object):
 
     def __init__(self):
         self.buf = bytearray()
-        self.state = PingParser.WAIT_START
-        self.payload_length = 0  # payload length remaining to be parsed for the message currently being parsed
-        self.message_id = 0  # message id of the message currently being parsed
+        self.state = self.WAIT_START
+        self.payload_length = 0 # remaining for the message currently being parsed
+        self.message_id = 0     # of the message currently being parsed
         self.errors = 0
         self.parsed = 0
-        self.rx_msg = None  # most recently parsed message
+        self.rx_msg = None      # most recently parsed message
 
-    # Feed the parser a single byte
-    # Returns the current parse state
-    # If the byte fed completes a valid message, return PingParser.NEW_MESSAGE
-    # The decoded message will be available in the self.rx_msg attribute until a new message is decoded
-    def parse_byte(self, msg_byte):
-        if type(msg_byte) != int:
-            msg_byte = ord(msg_byte)
-        # print("byte: %d, state: %d, rem: %d, id: %d" % (msg_byte, self.state, self.payload_length, self.message_id))
-        if self.state == PingParser.WAIT_START:
-            self.buf = bytearray()
-            if msg_byte == ord('B'):
-                self.buf.append(msg_byte)
-                self.state += 1
-        elif self.state == PingParser.WAIT_HEADER:
-            if msg_byte == ord('R'):
-                self.buf.append(msg_byte)
-                self.state += 1
-            else:
-                self.state = PingParser.WAIT_START
-        elif self.state == PingParser.WAIT_LENGTH_L:
-            self.payload_length = msg_byte
-            self.buf.append(msg_byte)
-            self.state += 1
-        elif self.state == PingParser.WAIT_LENGTH_H:
-            self.payload_length = (msg_byte << 8) | self.payload_length
-            self.buf.append(msg_byte)
-            self.state += 1
-        elif self.state == PingParser.WAIT_MSG_ID_L:
-            self.message_id = msg_byte
-            self.buf.append(msg_byte)
-            self.state += 1
-        elif self.state == PingParser.WAIT_MSG_ID_H:
-            self.message_id = (msg_byte << 8) | self.message_id
+    def wait_start(self, msg_byte):
+        self.buf = bytearray()
+        if msg_byte == ord('B'):
             self.buf.append(msg_byte)
             self.state += 1
-        elif self.state == PingParser.WAIT_SRC_ID:
+
+    def wait_header(self, msg_byte):
+        if msg_byte == ord('R'):
             self.buf.append(msg_byte)
             self.state += 1
-        elif self.state == PingParser.WAIT_DST_ID:
-            self.buf.append(msg_byte)
+        else:
+            self.state = self.WAIT_START
+
+    def wait_length_l(self, msg_byte):
+        self.payload_length = msg_byte
+        self.buf.append(msg_byte)
+        self.state += 1
+
+    def wait_length_h(self, msg_byte):
+        self.payload_length |= (msg_byte << 8)
+        self.buf.append(msg_byte)
+        self.state += 1
+
+    def wait_msg_id_l(self, msg_byte):
+        self.message_id = msg_byte
+        self.buf.append(msg_byte)
+        self.state += 1
+
+    def wait_msg_id_h(self, msg_byte):
+        self.message_id |= (msg_byte << 8)
+        self.buf.append(msg_byte)
+        self.state += 1
+
+    def wait_src_id(self, msg_byte):
+        self.buf.append(msg_byte)
+        self.state += 1
+
+    def wait_dst_id(self, msg_byte):
+        self.buf.append(msg_byte)
+        self.state += 1
+        if self.payload_length == 1: # no payload bytes -> skip waiting
             self.state += 1
-            if self.payload_length == 0:  # no payload bytes
-                self.state += 1
-        elif self.state == PingParser.WAIT_PAYLOAD:
-            self.buf.append(msg_byte)
-            self.payload_length -= 1
-            if self.payload_length == 0:
-                self.state += 1
-        elif self.state == PingParser.WAIT_CHECKSUM_L:
-            self.buf.append(msg_byte)
+
+    def wait_payload(self, msg_byte):
+        self.buf.append(msg_byte)
+        self.payload_length -= 1
+        if self.payload_length == 0: # no payload bytes remaining -> stop waiting:
             self.state += 1
-        elif self.state == PingParser.WAIT_CHECKSUM_H:
-            self.buf.append(msg_byte)
-            self.rx_msg = PingMessage(msg_data=self.buf)
 
-            # print(self.rx_msg)
+    def wait_checksum_l(self, msg_byte):
+        self.buf.append(msg_byte)
+        self.state += 1
 
-            self.state = PingParser.WAIT_START
-            self.payload_length = 0
-            self.message_id = 0
+    def wait_checksum_h(self, msg_byte):
+        self.state = self.WAIT_START
+        self.payload_length = 0
+        self.message_id = 0
 
-            if self.rx_msg.verify_checksum():
-                self.parsed += 1
-                return PingParser.NEW_MESSAGE
-            else:
-                # TODO add/return error state
-                print("parse error")
-                self.errors += 1
+        self.buf.append(msg_byte)
+        self.rx_msg = PingMessage(msg_data=self.buf)
+
+        if self.rx_msg.verify_checksum():
+            self.parsed += 1
+            return self.NEW_MESSAGE
+        else:
+            # TODO add/return error state
+            print("parse error")
+            self.errors += 1
 
         return self.state
 
+    def parse_byte(self, msg_byte):
+        """ Returns the current parse state after feeding the parser a single byte.
+
+        'msg_byte' is the byte to parse.
+            If it completes a valid message, returns PingParser.NEW_MESSAGE.
+            The decoded PingMessage will be available in the self.rx_msg attribute
+                until a new message is decoded.
+
+        """
+        # Apply the relevant parsing method for the current state.
+        #  (offset by 1 because NEW_MESSAGE isn't processed - start at WAIT_START)
+        result = self._PARSE_BYTE[self.state - 1](self, msg_byte)
+
+        return self.state if result is None else result
+
+    # Tuple of parsing methods, in order of parser state
+    #  at bottom because otherwise methods won't be defined
+    _PARSE_BYTE = (
+        wait_start,
+        wait_header,
+        wait_length_l,
+        wait_length_h,
+        wait_msg_id_l,
+        wait_msg_id_h,
+        wait_src_id,
+        wait_dst_id,
+        wait_payload,
+        wait_checksum_l,
+        wait_checksum_h,
+    )
+
 
 if __name__ == "__main__":
     # Hand-written data buffers for testing and verification