public LoopTagSupport() 
{
        super();
        init();
}

Constructs a new LoopTagSupport. As with TagSupport, subclasses should not implement constructors with arguments, and no-arguments constructors implemented by subclasses must call the superclass constructor.

 public int doAfterBody() throws JspException 
{
        // re-sync the index, given our prior behind-the-scenes 'step'
        index += step - 1;
        // increment the count by 1 for each round
        count++;
        // everything's been prepared for us, so just get the next item
        if (hasNext() && !atEnd()) {
            index++;
            item = next();
        } else
            return SKIP_BODY;
        /*
         * now discard anything we have to "step" over.
         * (we do this in advance to support LoopTagStatus.isLast())
         */
        discard(step - 1);
        // prepare to re-iterate...
        exposeVariables(false);
        calibrateLast();
        return EVAL_BODY_AGAIN;
}

Continues the iteration when appropriate -- that is, if we (a) have more items and (b) don't run over our 'end' (given our 'step').

 public  void doCatch(Throwable t) throws Throwable 
{
	throw t;
}

Rethrows the given Throwable.

 public  void doFinally() 
{
	/*
	 * Make sure to un-expose variables, restoring them to their
	 * prior values, if applicable.
         */
	unExposeVariables();
}

Removes any attributes that this LoopTagSupport set.

These attributes are intended to support scripting variables with NESTED scope, so we don't want to pollute attribute space by leaving them lying around.

 public int doStartTag() throws JspException 
{
        if (end != -1 && begin  > end) {
            // JSTL 1.1. We simply do not execute the loop.
            return SKIP_BODY;
        }
        // we're beginning a new iteration, so reset our counts (etc.)
        index = 0;
        count = 1;
        last = false;
        iteratedExpression = null;
        deferredExpression = null;
        // let the subclass conduct any necessary preparation
        prepare();
        // throw away the first 'begin' items (if they exist)
        discardIgnoreSubset(begin);
        // get the item we're interested in
        if (hasNext())
            // index is 0-based, so we don't update it for the first item
            item = next();
        else
            return SKIP_BODY;
        /*
         * now discard anything we have to "step" over.
         * (we do this in advance to support LoopTagStatus.isLast())
         */
        discard(step - 1);
        // prepare to include our body...
        exposeVariables(true);
        calibrateLast();
        return EVAL_BODY_INCLUDE;
}

Begins iterating by processing the first item.

 public Object getCurrent() 
{
        return item;
}

 protected String getDelims() 
{
        return ",";
}

 public LoopTagStatus getLoopStatus() 
{
        // local implementation with reasonable default behavior
        class Status implements LoopTagStatus {
            /*
             * All our methods are straightforward.  We inherit
             * our JavaDoc from LoopTagSupport; see that class
             * for more information.
             */
            public Object getCurrent() {
                /*
                 * Access the item through getCurrent() instead of just
                 * returning the item our containing class stores.  This
                 * should allow a subclass of LoopTagSupport to override
                 * getCurrent() without having to rewrite getLoopStatus() too.
                 */
                return (LoopTagSupport.this.getCurrent());
            }
            public int getIndex() {
                return (index + begin);       // our 'index' isn't getIndex()
            }
            public int getCount() {
                return (count);
            }
            public boolean isFirst() {
                return (index == 0);          // our 'index' isn't getIndex()
            }
            public boolean isLast() {
                return (last);                // use cached value
            }
            public Integer getBegin() {
                if (beginSpecified)
                    return Integer.valueOf(begin);
                else
                    return null;
            }
            public Integer getEnd() {
                if (endSpecified)
                    return Integer.valueOf(end);
                else
                    return null;
            }
            public Integer getStep() {
                if (stepSpecified)
                    return Integer.valueOf(step);
                else
                    return null;
            }
        }
        /*
         * We just need one per invocation...  Actually, for the current
         * implementation, we just need one per instance, but I'd rather
         * not keep the reference around once release() has been called.
         */
        if (status == null)
            status = new Status();
        return status;
}

 abstract protected boolean hasNext() throws JspTagException
Returns information concerning the availability of more items
over which to iterate.  This method must be provided by concrete
subclasses of LoopTagSupport to assist the iterative logic
provided by the supporting base class.
 
See next for more information about the
purpose and expectations behind this tag.

 abstract protected Object next() throws JspTagException
Returns the next object over which the tag should iterate.  This
method must be provided by concrete subclasses of LoopTagSupport
to inform the base logic about what objects it should iterate over.

It is expected that this method will generally be backed by an
Iterator, but this will not always be the case.  In particular, if
retrieving the next object raises the possibility of an exception
being thrown, this method allows that exception to propagate back
to the JSP container as a JspTagException; a standalone Iterator
would not be able to do this.  (This explains why LoopTagSupport
does not simply call for an Iterator from its subtags.)

 abstract protected  void prepare() throws JspTagException
Prepares for a single tag invocation.  Specifically, allows
subclasses to prepare for calls to hasNext() and next(). 
Subclasses can assume that prepare() will be called once for
each invocation of doStartTag() in the superclass.

 public  void release() 
{
        super.release();
        init();
}

Releases any resources this LoopTagSupport may have (or inherit).

 public  void setVar(String id) 
{
        this.itemId = id;
}

Sets the 'var' attribute.

 public  void setVarStatus(String statusId) 
{
        this.statusId = statusId;
}

Sets the 'varStatus' attribute.

 protected  void validateBegin() throws JspTagException 
{
        if (begin <  0)
            throw new JspTagException("'begin' <  0");
}

Ensures the "begin" property is sensible, throwing an exception expected to propagate up if it isn't

 protected  void validateEnd() throws JspTagException 
{
        if (end <  0)
            throw new JspTagException("'end' <  0");
}

Ensures the "end" property is sensible, throwing an exception expected to propagate up if it isn't

 protected  void validateStep() throws JspTagException 
{
        if (step <  1)
            throw new JspTagException("'step' < = 0");
}

Ensures the "step" property is sensible, throwing an exception expected to propagate up if it isn't