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:*=null)
		{
			super(policy, buildTree, annotateEdges, root, edgeWeight);
		}
		
		/** @inheritDoc */
		public function operate(t:Transitioner=null):void
		{
			super.calculate(visualization.data, root);
		}
		
		/** @inheritDoc */
		public function setup():void
		{
			// for subclasses
		}
		
		// -- MXML ------------------------------------------------------------
		
		/** @private */
		public function initialized(document:Object, id:String):void
		{
			// do nothing
		}
		
	} // end of class SpanningTree
}