For something this small, use a single VI to manage it in memory:
It has a FUNCTION input, an enum with values of (INIT, READ FILE,
WRITE FILE, ADD ITEM, FIND ITEM).
It has a CLUSTER input, which is your record type {Item number, serial
number, time stamp, description}
It has a CLUSTER output, of the same type.
It has an ITEM NUMBER input, which is an integer (assuming your item
number is truly a number).
The code is a WHILE loop with the CONTINUE input wired to FALSE (it
never loops).
Inside the WHILE LOOP is a CASE statement, with the selector wired to
the FUNCTION control.
For case INIT, make an empty array of records (your cluster type) and
feed it to a shift register on the WHILE loop.
For case WRITE FILE, take the shift register input and CREATE, WRITE,
and CLOSE a file. (pass it thru to the output as well). Wire the
cluster to the DATALOG TYPE of the CREATE FILE function to create a
datalog file.
For case READ FILE, use OPEN FILE, READ FILE, and CLOSE FILE
functions, with DATALOG TYPE wired to the cluster type.
For case ADD ITEM, just append the new item (input cluster control) to
the array from the shift reg and put the array back in the shift reg.
For case FIND ITEM, just search thru the array (from the shift reg)
until you find the matching item number, then return the whole record
in the output.
You'll have to pass the left shift reg thru the case to the right
shift reg in all cases except INIT, READ FILE, and ADD ITEM.
This means the actual storage is in the shift reg, for max efficiency.
If you get beyound a hundred items, I would suggest a different FIND
ITEM technique (keep a separate list for ITEM NUMBERS and search that,
rather than the whole thing).
This assumes you have control of shutdown - any changes you make are
lost unless you call WRITE FILE afterwards.
