    package flare.vis.operator
    {
        import flare.animate.Transitioner;

        /**
         * An OperatorSwitch maintains a list of operators but only runs one
         * of these operators when invoked. A switch allows different operator
         * chains to be executed at different times. Operators can be added to
         * an OperatorSwitch using the <code>add</code> method. Once added,
         * operators can be retrieved and set using their index in the list, either
         * with array notation (<code>[]</code>) or with the
         * <code>getOperatorAt</code> and <code>setOperatorAt</code> methods.
         *
         * <p>The current sub-operator to run is determined by
         * the <tt>index</tt> property. This index can be set manually or can
         * be automatically determined upon each invocation by assigning a
         * custom function to the <tt>indexFunction</tt> property.</p>
         */
        public class OperatorSwitch extends OperatorList
        {
            private var _cur:int = -1;

            /** The currently active index of the switch. Only the operator at this
             *  index is run when the <code>operate</code> method is called. */
            public function get index():int { return _cur; }
            public function set index(i:int):void { _cur = i; }

            /**
             * A function that determines the current index value of this
             * OperatorSwitch. This can be used to have the operator automatically
             * adjust which sub-operators to run. If this property is non-null,
             * the function will be invoked each time this OperatorSwitch is run
             * and the index property will be set with the resulting value,
             * overriding any previous index setting.
             * The index function should accept zero arguments and return an
             * integer that is a legal index value for this switch. If the
             * returned value is not a legal index value (i.e., it is not an
             * integer or is out of bounds) then no sub-operators will be
             * run.
             */
            public var indexFunction:Function = null;

            // --------------------------------------------------------------------

            /**
             * Creates a new OperatorSwitch.
             * @param ops an ordered set of operators to include in the switch.
             */
            public function OperatorSwitch(...ops) {
                for each (var op:IOperator in ops) {
                    add(op);
                }
            }

            /** @inheritDoc */
            public override function operate(t:Transitioner=null):void
            {
                t = (t!=null ? t : Transitioner.DEFAULT);
                if (indexFunction != null) {
                    _cur = indexFunction();
                }
                if (_cur >= 0 && _cur < _list.length && _list[_cur].enabled)
                    _list[_cur].operate(t);
            }

        } // end of class OperatorSwitch
    }