Parse array of variants

Question

I have an application where we read binary data over Ethernet at a fast rate (~500 Hz). This data consists of many hundreds of measurements and other variables of all different types (floats, ints, strings, etc). I already have the code to parse this data and store it as an array of variants.
Now, I would like to take that array of variants and map each element to a specific variable.
Because the data is stored in a predefined sequence (Element #1 = speed, Element #2 = power, Element #3 = ...), I considered looping over the array of variants and using a case structure with a case for each index of the array (see attachment). However, this is very cumbersome as the case structure has hundreds of cases (one for each array element) and it is impossible to insert a new element in the case structure without manually re-numbering all of the cases.
Can anyone point me to a simpler implementation? If I was using C, I would probably memcpy the binary data directly into a byte-aligned structure. Is there an equivalent in LabVIEW using clusters? 
(Note: using LabVIEW 2014)
Solved!
Go to Solution.
Attachments:
variant_to_data.png ‏7 KB

Answer 1

I suppose that what you can do - similar to what you wanted to do in your first post about copying it into a structure in C - is create a type definition for your data structure coming across the network, which would be a cluster of all of your values, and then TypeCast / Unflatten From String into that.  From your image, it looks like you have at least 122 values.  That will be one big cluster, but I suppose that if that is your data structure, then that is your data structure.
By creating a Type Definition, you can gain some maintanability in that if you ever need to reorder, add, or remove data, removing it from your TypeDef should propagate everywhere, and giving every element a name and always using Unbundle by Name ensures that you are always getting the relevent element at each point of use even after changing anything.
Attached is an example of a Cluster TypeDef, and two code snippets follow:
The former uses the Unflatten From String function.  Usually the way to go with unflattening strings.
The latter uses TypeCast.  Functionally identical in this exact case, but probably not advised in this case as:
You don't have options of specifying byte ordering
You don't have options of specifying if the string contains the length at the beginning
You don't have error out to indicate that the conversion was unsuccessful
For some reason you cannot wire non-fixed-size clusters to the TypeCast function.
I do wonder if anyone has a good solution for the initial problem, though.  Consider what if one's data was actually being sent as an array of variants by some other application - how would one best handle that?
Attachments:
Cluster_Type_Definition.ctl ‏9 KB