fn shuffle_flatten()

in protocol/src/suid_create/sharer.rs [192:282]
68 lines of code
3 McCabe index (conditional complexity)

    fn shuffle_flatten(
        &self,
        mut data: Vec<(Vec<Vec<TPoint>>, Vec<Vec<TPoint>>)>,
    ) -> Result<TPayload, ProtocolError> {
        match (
            self.permutation.clone().write(),
            self.num_entries.clone().write(),
        ) {
            (Ok(mut permutation), Ok(mut num_entries)) => {
                num_entries.clear();
                num_entries.extend(data.iter().map(|(x, _)| x.len()).collect::<Vec<_>>());

                let total_entries = num_entries.iter().sum();

                permutation.clear();
                permutation.extend(gen_permute_pattern(total_entries));

                let (c1_buf, c2_buf, offset) = {
                    let mut c1 = Vec::<Vec<TPoint>>::new();
                    for x in data.iter_mut() {
                        c1.append(&mut x.0);
                    }

                    let mut c2 = Vec::<Vec<TPoint>>::new();
                    for x in data.iter_mut() {
                        c2.append(&mut x.1);
                    }

                    assert_eq!(c1.len(), c2.len());
                    assert_eq!(c1.len(), permutation.len());

                    // Free up memory
                    data.clear();
                    data.shrink_to_fit();

                    // Global permute
                    permute(permutation.as_slice(), &mut c1);
                    permute(permutation.as_slice(), &mut c2);

                    // Flatten and calculate offsets for unflattening
                    let (c1_f, offset_c1, _) = serialize_helper(c1);
                    let (c2_f, offset_c2, _) = serialize_helper(c2);

                    assert_eq!(c1_f.len(), c2_f.len());
                    assert_eq!(offset_c1.len(), offset_c2.len());

                    // Check if the vectors are identical
                    assert_eq!(
                        offset_c1
                            .iter()
                            .zip_eq(offset_c2.iter())
                            .filter(|&(a, b)| a != b)
                            .count(),
                        0
                    );

                    (
                        self.ec_cipher.to_bytes(&c1_f),
                        self.ec_cipher.to_bytes(&c2_f),
                        offset_c1,
                    )
                };

                let offset_len = offset.len();

                let mut buf = c1_buf;
                buf.extend(c2_buf);

                let data_len = buf.len();

                // Push only one offset for two data since both should
                // have same shape
                buf.extend(offset);

                buf.push(ByteBuffer {
                    buffer: (data_len as u64).to_le_bytes().to_vec(),
                });
                buf.push(ByteBuffer {
                    buffer: (offset_len as u64).to_le_bytes().to_vec(),
                });

                Ok(buf)
            }
            _ => {
                error!("Unable to shuffle data");
                Err(ProtocolError::ErrorShuffle(
                    "unable to shuffle data".to_string(),
                ))
            }
        }
    }