So CompositeTypes... are pretty compelling. Seems like they either are similar or actually are Js Object Types as you can use the Object() constructor to create instances that will match up with a CompositeType easily enough. They seem better than working with Properties.
I have been doing quite a bit of discovery today, and I managed to get an Array of CTs to be rather workable. I am sure there are some out there who find my minor skills remedial, but I am sure there are others who would be interested in seeing some of my testing results. Where I am seeing a benefit with these types is: whilst in the execution of a workflow, data from different sources and of different types can be put together and referenced logically as a single object. An array of these objects allows foreach activities, search activities, database loads, etc to be object.name-referential. I have no idea if CompositeTypes will always be supported in vRO or if they have a shelf life. It is interesting nonetheless...
I created a single composite type as an Array...
I added a couple of values...
Ran workflow from a single Scriptable Task with the below script with a single input of the arrayComp composite type. .
// One Array of Composite types defined as an Attribute as
// Array/CompositeType(name:string,notes:string):test) arrayComp
// One DEFAULT Input was added as the first position in the array
// through Attribute Value input. name:"one",notes:"two"
// Note: Composite Types do not need to have all the same types defined
//(e.g. "string, string" could be "string, object, number, VCAC:VirtualMachine"
//create an object with a third variable to overload Array position 2.
var testing = new Object();
testing.name = "bob";
testing.notes = "slob";
testing.extra = "job-overload"; // overload
arrayComp.push(testing); // load testing object into arrayComp
System.log("Pushed Object into Composite Array with extra value position...");
System.log("arrayComp length = " +arrayComp.length); // Array is 2 CompositeType Units long now
System.log("Listing to show extra value...");
System.log(arrayComp[1].name);
System.log(arrayComp[1].notes);
System.log(arrayComp[1].extra); // This only exists in the second array object
System.log ("Looping through all Composite Types with Sys logs to show extra position is *undefined* in Array position 1...");
for each (Comp in arrayComp)
{ System.log(Comp.name); System.log(Comp.notes); System.log(Comp.extra); // only overloaded Composite type maintains extra position }
//This tests creating an Object with the same mapping as the Composite Type
//...then overwritting the first Compsite Type in the Array with the Objects values
System.log("Test Replacement of one Composite Type in an Array with an Object");
var replacement = new Object();
replacement.name = "sam";
replacement.notes = "ham";
System.log("Replacing Array position 1 with new value, object overwrite.");
arrayComp[0] = replacement; // Takes Object and overwrites arrayComp[0] slot
for each (Comp in arrayComp)
{ System.log(Comp.name); System.log(Comp.notes); System.log(Comp.extra); }
//Test removing a Composite Type from array and assign to variable to work with individually
System.log("Pull off last CompositeType into a single Composite variable...");
var singleComp = arrayComp.pop();
System.log("arrayComp length = " +arrayComp.length); // Array is 1 CompositeType Units long now
System.log(singleComp.name);
System.log(singleComp.notes);
System.log(singleComp.extra); // last Array position was overloaded so this exists
//Test assignment of composite type to new array position
System.log("Push Composite type in first array position back into array...");
arrayComp.push(arrayComp[0]);
System.log("arrayComp length = " +arrayComp.length); // Array is 2 CompositeType Units long now
for each (Comp in arrayComp)
{ System.log(Comp.name); System.log(Comp.notes); }
//Test direct assignment
System.log("Direct Assignment...");
arrayComp[1].notes = "Bologna";
for each (Comp in arrayComp)
{ System.log(Comp.name); System.log(Comp.notes); }
// Strange behavior noted with above. Bologna should have only printed in second array position.
// Overload arrayComp[1]
System.log("Strange Behavior...");
arrayComp[1].extra = "WTF-over";
for each (Comp in arrayComp)
{ System.log(Comp.name); System.log(Comp.notes); System.log(Comp.extra); }
//arrayComp[0] and arrayComp[1] are the same thing (pointer to same place?)... careful with that in the future
// Test push back in the singeComp Composite Type
System.log("Push back in singleComp.");
arrayComp.push(singleComp);
System.log("arrayComp length = " +arrayComp.length); // Array is 3 CompositeType Units long now
for each (Comp in arrayComp)
{ System.log(Comp.name); System.log(Comp.notes); System.log(Comp.extra); }
// Direct modification of array position 3, *extra* variable
arrayComp[2].extra = "no-job. The end.";
for each (Comp in arrayComp)
{ System.log(Comp.name); System.log(Comp.notes); System.log(Comp.extra); }
// fin