Iterating through data structure - actionscript-3

Question

I'm kinda wracking my brain on how to iterate through my data object. I've created a recursive function to iterate through XML elements and essentially output the same structure as an object, using the attribute in the element as the key, which holds it's own object. The object, conceptually, looks something like this. It's sort of a Tree, but I'm not using flex Trees, just as3.
The thing I want to get across is that each "branch" has any number of children, so I can't hard code the depth of each branch.
What I'm trying to accomplish
Each node in my data structure is a folder name, and I need to append all of the children into a single string and store that. To generate an "asset", i need a string from each of these initial nodes (in the example picture, they'd be 1, 2, 4, 5, 6, and 17). So, I need to iterate through each branch and return a different set than previously, such that every possible asset combination is found.
Conceptually, I know that I need to grab the "1st index" of each branch, output all of those strings into an asset, and then move the first branch up an "index" until it reaches it's limit, which triggers the next branch to move its "index". But, how I actually do that is a bit of a mystery to me.
Do I need to restructure my data tree into an array that can be referenced by index, or is there some simpler way of iterating through every possible combination that I am missing.
I'm using actionscript 3, but I'm not specifically looking for a code example, just pseudo-code is fine.

Answer 1

Because you're trying to pull out the N'th of every tree into a seperate array of strings, it'll be easier to first distill these trees into their sequential sets (with their concatenations) in a first pass. A second pass then constructs your intended "asset" arrays. Because the nature of your document may vary wildly, I've created a demonstration data source below. You can run the following code, and it will produce the following results:
//Assume the following structure.
var data:Array = [
{
"path":"one",
"sub":[
{
"path":"seven",
"sub":[
{"path":"nine.png"},
{"path":"ten.png"}
]
},
{
"path":"eight",
"sub":[
{"path":"eleven.png"},
{"path":"twelve.png"}
]
}
]
},
{
"path":"two",
"sub":[
{"path":"thirteen.png"},
{"path":"fourteen.png"},
{"path":"fifteen.png"},
{"path":"sixteen.png"}
]
},
{
"path":"four",
"sub":[
{
"path":"seventeen",
"sub":[
{"path":"nineteen.png"},
{"path":"twenty.png"}
]
},
{
"path":"twenty-two",
"sub":[
{"path":"twenty-one.png"},
{"path":"twenty-two.png"}
]
}
]
},
{
"path":"five",
"sub":[
{"path":"twenty-three.png"}
]
},
{
"path":"six",
"sub":[
{
"path":"twenty-four",
"sub":[
{"path":"twenty-six.png"},
{"path":"twenty-seven.png"}
]
},
{
"path":"twenty-nine",
"sub":[
{"path":"twenty-eight.png"},
{"path":"twenty-nine.png"}
]
}
]
},
{
"path":"seventeen",
"sub":[
{"path":"thirtee.png"}
]
}
]
function init():void {
var sets:Array = [];
// First we'll create a complete sequence of concatenated strings per set
for (var i:int = 0; i < data.length; i++) {
sets[i] = [];
scan(data[i], sets[i]);
}
// Find the max length
var max:int = 0, a:Array;
for each (a in sets) {
max = (a.length > max) ? a.length : max;
}
// Now we'll create our ordered assets, pulling out the firsts, then the seconds, and so on...
var assets:Array = [];
for (i = 0; i < max; i++) {
assets[i] = [];
for each (a in sets) {
if (i < a.length) {
assets[i].push(a[i]);
}
}
}
}
function scan(node:Object, a:Array, prefix:String = ""):void {
var subNode:Object;
// This is a recursive function which digs till it finds no more sub properties.
if (node.hasOwnProperty("sub")) {
// On every sub node, it passes the currently concatenated path so far
for each (subNode in node.sub) {
scan(subNode, a, prefix + "/" + node.path);
}
} else {
// When we reach the final depth, we can begin populating our array with paths.
a.push(prefix + "/" + node.path);
}
}
init();