var xmlList:XMLList = myXml.node..items;
var collection:XMLListCollection = new XMLListCollection(xmlList);
var cursor:IViewCursor = collection.createCursor();
 

package com.pbking.application.commands
{
  import com.ender.threads.Thread;
  import com.pbking.app.command.ThreadedCommand;
  import mx.collections.IViewCursor;
  import mx.collections.XMLListCollection;

  public class ParseClientData extends ThreadedCommand
  {
    private var data:XML;
    private var seatsToProcess:XMLListCollection;
    private var cursor:IViewCursor;

    public function ParseClientData(data:XML)
    {
      super();
     
      this.data = data;
     
      //I’m not doing anything else while this is going on
      //so I’m setting it to URGENT PRIORITY so that it
      //runs every frame.
      this.priority = Thread.URGENT_PRIORITY;

      //this will calculate the optimum number of iterations
      //that should be made in a single run (starting with 2 per run)
      this.autoOptimizeIterations = true;
      this.iterationsPerRun = 2;
    }
   
    override protected function handleExecution():void
    {
      //handle execution is called once before any runs
      //create my collection from my data and a cursor from that collection
      seatsToProcess = new XMLListCollection(data.clientDataXML..seat);
      cursor = seatsToProcess.createCursor();
     
      //the first run will start in the super handler
      super.handleExecution();
    }
   
    override protected function handleRun():void
    {
      var infoX:XML;

      //checking to see if I have made as many passes as I should (iterationCount vs iterationsPerRun
      //or if I have moved past the end of the collection (cursor.afterLast)     
      while(iterationCount < iterationsPerRun && !cursor.afterLast)
      {
        //pull the current node from my cursor
        //I’ll move the cursor on at the end of this while loop
        infoX = cursor.current as XML;
       
        //do all of my magic processing on the infoX object.
        //processing each of these takes a while; that’s why it’s
        //in a psudo-thread.
       
        //the benefit of using a cursor here instead of a recorded index
        //is that now I can add/subtract things from my collection
        //(either here or elsewhere) and the code can still handle that

        //this next value helps the optimizer (in the parent ThreadedCommand class)
        //know how many elements were processed and will automatically
        //adjust the iterationsPerRun based on how long the run took
        //and the desired amount of time per run
        iterationCount++;
       
        // This moves the cursor to the next element.
        // cursor.current has now advanced to the next element
        // and if we’ve gone past the end then cursor.afterLast is true
        cursor.moveNext();
      }

      if(cursor.afterLast)
      {
        //all done; wrap up the command
        onComplete();  
      }
      else
      {
        //yeield the command. We’ll come back and finish up later
        //with another call to run()
        yield();
      }
    }
   
  }
}