Improvement to QuickDrop Ctrl+W tool: Prefer destinations that match source data type exactly

[Petru_Tarabuta]

The Wire Multiple Objects Together QuickDrop tool (Ctrl + W) is extremely useful. However, at the moment it has the following limitation.

The other day I found myself writing code like the following.

Naturally I tried using the QuickDrop Ctrl + W tool. However, it produced the result seen below, which is not what I wanted.

The Ctrl + W tool wires each source wire to a compatible (coerceable) destination. In the example above it wires to I32 and DBL destinations indiscriminately.

The desired outcome would be achieved if the tool preferred wiring to destinations that match the source data type exactly, before considering other compatible (coercible) destinations. In the example above, the tool should prefer the DBL destinations. It should wire to the DBL destinations first, before considering I32 destinations.

Notes

• The example above shows 10 wires being wired between the Index Array node and the Replace Array Subset node. The real-world VIs I was programming the other day required wiring multiple pairs of Index Array and Replace Array Subset nodes, some with as many as 30 wires between them. Wiring them manually was a tedious and time-consuming operation.
• This idea is somewhat related to the following idea: Improvement to the QuickDrop Ctrl+W tool: Wire constant to multiple destinations

[raphschru]

I agree with the idea of improving the auto-wire functionality, however I must question the use case of wiring so many terminals.

Why so complicated?

Regards,

Raphaël.

[Petru_Tarabuta]

Hi Raphaël,

Thanks for your comment. I am aware of the technique you showed above, and I have used it in a few other locations in the same codebase. You are right that the "This is what I wanted to achieve" screenshot in the original post could/should be refactored to what you showed.

My description of what I wanted to achieve was incomplete. The "This is what I wanted to achieve" screenshot shows the first part of what I wanted to achieve. After achieving it, I then manually wired I32 constants to the index inputs of the Replace Array Subset primitive. Such that the end-result was different than shown in the initial image (in addition to what is shown, non-consecutive I32 indexes were wired too).

The goal was to replace a non-continuous subset of elements in the most computationally efficient manner possible. For this reason I avoided using a for loop with auto-indexing 1D array inputs.

[wiebe@CARYA]

Note that the simplification doesn't have the same effect

Spoiler

It's the same iff the 1D Array of DBL is exactly the size of the number of elements to insert.

Indexing and inserting enforces the number of elements that is inserted, using element defaults (0) if the element doesn't exist in the source array.

You'd have to use Resize Array to make sure the inserted array is the expected size to make sure the refactored code keeps working..