serial: The - List that this SimpleSequence wraps.

 public SimpleSequence() 
{
        this((ObjectWrapper) null);
}

Constructs an empty simple sequence that will use the the default object wrapper set in WrappingTemplateModel#setDefaultObjectWrapper(ObjectWrapper) .

 public SimpleSequence(int capacity) 
{
        list = new ArrayList(capacity);
}

Constructs an empty simple sequence with preallocated capacity and using the default object wrapper set in WrappingTemplateModel#setDefaultObjectWrapper(ObjectWrapper) .

 public SimpleSequence(Collection collection) 
{
        this(collection, null);
}

Constructs a simple sequence that will contain the elements from the specified Collection and will use the the default object wrapper set in WrappingTemplateModel#setDefaultObjectWrapper(ObjectWrapper) .

Parameters:

collection - the collection containing initial values. Note that a copy of the collection is made for internal use.

 public SimpleSequence(TemplateCollectionModel tcm) throws TemplateModelException 
{
        ArrayList alist = new ArrayList();
        for (TemplateModelIterator it = tcm.iterator(); it.hasNext();) {
            alist.add(it.next());
        }
        alist.trimToSize();
        list = alist;
}

Constructs a simple sequence from the passed collection model using the default object wrapper set in WrappingTemplateModel#setDefaultObjectWrapper(ObjectWrapper) .

 public SimpleSequence(ObjectWrapper wrapper) 
{
        super(wrapper);
        list = new ArrayList();
}

Constructs an empty simple sequence using the specified object wrapper.

Parameters:

wrapper - The object wrapper to use to wrap objects into TemplateModel instances. If null, the default wrapper set in WrappingTemplateModel#setDefaultObjectWrapper(ObjectWrapper) is used.

 public SimpleSequence(Collection collection,
    ObjectWrapper wrapper) 
{
        super(wrapper);
        list = new ArrayList(collection);
}

Constructs a simple sequence that will contain the elements from the specified Collection and will use the specified object wrapper.

Parameters:

collection - the collection containing initial values. Note that a copy of the collection is made for internal use.

wrapper - The object wrapper to use to wrap objects into TemplateModel instances. If null, the default wrapper set in WrappingTemplateModel#setDefaultObjectWrapper(ObjectWrapper) is used.

 public  void add(Object obj) 
{
        list.add(obj);
        unwrappedList = null;
}

Adds an arbitrary object to the end of this SimpleSequence. If the object itself does not implement the TemplateModel interface, it will be wrapped into an appropriate adapter on the first call to #get(int) .

 public  void add(boolean b) 
{
        if (b) {
            add(TemplateBooleanModel.TRUE);
        } 
        else {
            add(TemplateBooleanModel.FALSE);
        }
}

Adds a boolean to the end of this SimpleSequence, by coercing the boolean into TemplateBooleanModel#TRUE or TemplateBooleanModel#FALSE .

 public TemplateModel get(int i) throws TemplateModelException 
{
        try {
            Object value = list.get(i);
            if (value instanceof TemplateModel) {
                return (TemplateModel) value;
            }
            TemplateModel tm = wrap(value);
            list.set(i, tm);
            return tm;
        }
        catch(IndexOutOfBoundsException e) {
            return null;
//            throw new TemplateModelException(i + " out of bounds [0, " + list.size() + ")");
        }
}

 public int size() 
{
        return list.size();
}

 public SimpleSequence synchronizedWrapper() 
{
        return new SynchronizedSequence();
}

 public List toList() throws TemplateModelException 
{
        if (unwrappedList == null) {
            Class listClass = list.getClass();
            List result = null;
            try {
                result = (List) listClass.newInstance();
            } catch (Exception e) {
                throw new TemplateModelException("Error instantiating an object of type " + listClass.getName() + "\n" + e.getMessage());
            }
            BeansWrapper bw = BeansWrapper.getDefaultInstance();
            for (int i=0; i< list.size(); i++) {
                Object elem = list.get(i);
                if (elem instanceof TemplateModel) {
                    elem = bw.unwrap((TemplateModel) elem);
                }
                result.add(elem);
            }
            unwrappedList = result;
        }
        return unwrappedList;
}

Note that this method creates and returns a deep-copy of the underlying list used internally. This could be a gotcha for some people at some point who want to alter something in the data model, but we should maintain our immutability semantics (at least using default SimpleXXX wrappers) for the data model. It will recursively unwrap the stuff in the underlying container.

 public String toString() 
{
        return list.toString();
}