Remove switch statement.

src/prrt/processes/data_receiver.c

@@ -94,75 +94,72 @@ void *receive_data_loop(void *ptr)
         check_mem(packet);
         PrrtPacket_decode(buffer, (uint16_t) n, packet);
 
-        switch(PrrtPacket_type(packet)) {
-            case PACKET_TYPE_DATA:
-                // TODO: packet.timestamp + packet.timeout < now: break
+        uint8_t packetType = PrrtPacket_type(packet);
+        if(packetType == PACKET_TYPE_DATA) {
+            // TODO: packet.timestamp + packet.timeout < now: break
 
-                if(PrrtForwardPacketTable_test_set_is_number_relevant(sock_ptr->forwardPacketTable, packet->seqno) ==
-                   false) {
-                    PrrtPacket_destroy(packet);
-                } else {
-                    uint16_t baseSequenceNumber = packet->seqno - packet->index;
+            if(PrrtForwardPacketTable_test_set_is_number_relevant(sock_ptr->forwardPacketTable, packet->seqno) ==
+               false) {
+                PrrtPacket_destroy(packet);
+            } else {
+                uint16_t baseSequenceNumber = packet->seqno - packet->index;
 
-                    PrrtPacket *reference = PrrtPacket_copy(packet);
+                PrrtPacket *reference = PrrtPacket_copy(packet);
 
-                    PrrtBlock *block = BPTree_get(sock_ptr->blockStore, baseSequenceNumber);
-                    if(block != NULL) {
-                        check(PrrtBlock_insert_data_packet(block, reference), "Inserting failed");
-                        decode_block(sock_ptr, block, baseSequenceNumber);
+                PrrtBlock *block = BPTree_get(sock_ptr->blockStore, baseSequenceNumber);
+                if(block != NULL) {
+                    check(PrrtBlock_insert_data_packet(block, reference), "Inserting failed");
+                    decode_block(sock_ptr, block, baseSequenceNumber);
+                } else {
+                    // Check for duplicate data packet.
+                    if(BPTree_get(sock_ptr->dataStore, packet->seqno) == NULL) {
+                        sock_ptr->dataStore = BPTree_insert(sock_ptr->dataStore, packet->seqno, reference);
                     } else {
-                        // Check for duplicate data packet.
-                        if(BPTree_get(sock_ptr->dataStore, packet->seqno) == NULL) {
-                            sock_ptr->dataStore = BPTree_insert(sock_ptr->dataStore, packet->seqno, reference);
-                        } else {
-                            PrrtPacket_destroy(reference);
-                        }
+                        PrrtPacket_destroy(reference);
                     }
+                }
 
-                    // forward to application layer
+                // forward to application layer
 
-                    pthread_mutex_lock(&sock_ptr->inQueueFilledMutex);
-                    List_push(sock_ptr->inQueue, packet);
-                    pthread_cond_signal(&sock_ptr->inQueueFilledCv);
-                    pthread_mutex_unlock(&sock_ptr->inQueueFilledMutex);
-                }
-                break;
-            case PACKET_TYPE_REDUNDANCY:
-                redundancyPayload = packet->payload;
+                pthread_mutex_lock(&sock_ptr->inQueueFilledMutex);
+                List_push(sock_ptr->inQueue, packet);
+                pthread_cond_signal(&sock_ptr->inQueueFilledCv);
+                pthread_mutex_unlock(&sock_ptr->inQueueFilledMutex);
+            }
+        } else if (packetType == PACKET_TYPE_REDUNDANCY) {
+            redundancyPayload = packet->payload;
 
-                if(!PrrtForwardPacketTable_test_is_block_relevant(sock_ptr->forwardPacketTable,
-                                                                  redundancyPayload->base_seqno,
-                                                                  redundancyPayload->n)) {
-                    PrrtPacket_destroy(packet);
-                } else {
-                    PrrtBlock *block = BPTree_get(sock_ptr->blockStore, redundancyPayload->base_seqno);
-                    if(block == NULL) {
-                        PrrtCodingParams *cpar = calloc(1, sizeof(PrrtCodingParams));
-                        PrrtCodingParams_init(cpar);
-                        cpar->k = redundancyPayload->k;
-                        cpar->n = redundancyPayload->n;
-
-                        block = calloc(1, sizeof(PrrtBlock));
-                        check_mem(block);
-                        PrrtBlock_create(block, cpar, redundancyPayload->base_seqno);
-                        free(cpar);
-                        sock_ptr->blockStore = BPTree_insert(sock_ptr->blockStore, redundancyPayload->base_seqno,
-                                                             block);
-                    }
+            if(!PrrtForwardPacketTable_test_is_block_relevant(sock_ptr->forwardPacketTable,
+                                                              redundancyPayload->base_seqno,
+                                                              redundancyPayload->n)) {
+                PrrtPacket_destroy(packet);
+            } else {
+                PrrtBlock *block = BPTree_get(sock_ptr->blockStore, redundancyPayload->base_seqno);
+                if(block == NULL) {
+                    PrrtCodingParams *cpar = calloc(1, sizeof(PrrtCodingParams));
+                    PrrtCodingParams_init(cpar);
+                    cpar->k = redundancyPayload->k;
+                    cpar->n = redundancyPayload->n;
+
+                    block = calloc(1, sizeof(PrrtBlock));
+                    check_mem(block);
+                    PrrtBlock_create(block, cpar, redundancyPayload->base_seqno);
+                    free(cpar);
+                    sock_ptr->blockStore = BPTree_insert(sock_ptr->blockStore, redundancyPayload->base_seqno,
+                                                         block);
+                }
 
-                    retrieve_data_blocks(sock_ptr, redundancyPayload->base_seqno, block->codingParams.k, block);
+                retrieve_data_blocks(sock_ptr, redundancyPayload->base_seqno, block->codingParams.k, block);
 
-                    if(PrrtBlock_insert_redundancy_packet(block, packet)) {
-                        decode_block(sock_ptr, block, redundancyPayload->base_seqno);
-                    } else {
-                        PrrtPacket_destroy(packet);
-                    }
+                if(PrrtBlock_insert_redundancy_packet(block, packet)) {
+                    decode_block(sock_ptr, block, redundancyPayload->base_seqno);
+                } else {
+                    PrrtPacket_destroy(packet);
                 }
-                break;
-            default:
-                PrrtPacket_print(packet);
-                PrrtPacket_destroy(packet);
-                break;
+            }
+        } else {
+            PrrtPacket_print(packet);
+            PrrtPacket_destroy(packet);
         }
     }