package flare.analytics.graph
{
    import flare.animate.Transitioner;
    import flare.vis.Visualization;
    import flare.vis.data.NodeSprite;
    import flare.vis.data.TreeBuilder;
    import flare.vis.operator.IOperator;
    import flare.vis.operator.Operator;

    /**
     * Calculates a spanning tree for a graph structure. This operator can
     * create spanning trees by breadth-first search, depth-first search, or by
     * computing a minimum spanning tree. The default is to find a minimum
     * spanning tree, which in turn defaults to breadth-first search if no edge
     * weight function is provided.
     * 
     * <p>This class can annotate graph edges as belonging to the spanning tree
     * (done if the <code>annotateEdges</code> property is true), and can
     * construct a <code>Tree</code> instance (done if the
     * <code>buildTree<code> property is true). Generated <code>Tree<code>
     * instances are stored in the <code>tree</code> property. Generated trees
     * contain the original nodes and edges in the input graph, and any
     * previous parent or child links for input nodes will be cleared and
     * overwritten.</p>
     * 
     * <p>This class extends the TreeBuilder class to also function as an
     * operator that can be added to a visualization's operator list.</p>
     */
    public class SpanningTree extends TreeBuilder implements IOperator
    {
        private var _vis:Visualization;
        private var _enabled:Boolean;
        
        /** @inheritDoc */
        public function get visualization():Visualization { return _vis; }
        public function set visualization(v:Visualization):void {
            _vis = v; setup();
        }
        
        /** @inheritDoc */
        public function get enabled():Boolean { return _enabled; }
        public function set enabled(b:Boolean):void { _enabled = b; }
        
        /** @inheritDoc */
        public function set parameters(params:Object):void
        {
            Operator.applyParameters(this, params);
        }
        
        // --------------------------------------------------------------------
        
        /**
         * Creates a new SpanningTree operator
         * @param policy the spanning tree creation policy. The default is
         *  <code>SpanningTree.MINIMUM_SPAN</code>
         * @param buildTree if true, this operator will build a new
         *  <code>Tree</code> instance containing the spanning tree
         * @param annotateEdges if true, this operator will annotate the
         *  edges of the original graph as belonging to the spanning tree
         * @param root the root node from which to compute the spanning tree
         * @param edgeWeight the edge weight values. This can either be a
         *  <code>Function</code> that returns weight values or a
         *  <code>String</code> providing the name of a property to look up on
         *  <code>EdgeSprite</code> instances.
         */
        public function SpanningTree(policy:String=null,
            buildTree:Boolean=false, annotateEdges:Boolean=true,
            root:NodeSprite=null, edgeWeight:*=n