The Xephyrus Data Structures Tag Library (das) provides an easy way to create and manipulate the contents of common Java data-structures such as maps and lists using JSP tags.

Within the das tag library there are two classes of tags: container tags and worker tags. Container tags define the specific structure being manipulated, including everything needed to create the underlying data object if needed. Worker tags do the data manipulation. Worker tags must be nested in container tags.

The hierarchy of the code underlying the tags is also classified by these types. The container tag hierarchical tree looks like so:

Similarly the worker tag hierarchical tree is like this:

In the simplest case of using a list, one would put some values into the list, then get them out. In this simple example we create a list with a list tag populate it with the names of some colors. That list is then used with the get tag to populate this drop down box with those color names.

There are a few details and variations on getting a value from a list. For example, you could get an item the get tag or using the JSP Expression Language or even (shudder) using Java scripting within the JSP. Here we reference list elements in various ways for grins and giggles.

Via a das:get tag:

Via an indexed EL statement:

Via a das:get tag using an intermediary variable:

Via a looped das:get tag using a looping variable:

To remove an element from a list, the das:remove tag is used. Since the element removed is retrieved during the removal, that element can be spewn to the output or stashed in a variable. To remove an element silently, assign it to a junk variable. If you haven't already noticed, elements in lists use a zero-based index. That won't be a surprise to Java programmers.

Remove the 5th element and write it to the output stream:

Remove the 7th element and stash it in a variable:

The size of any given list can be spouted directly to the output stream or stuffed in a variable. Here's an example of spoutage:

Here we will throw a list together which is sorted. Since sorting happens in the container itself, all other operations work the same way as if the list wasn't sorted (except insofar as the order of the list elements is concerned, of course).

Any external class can be referenced as a list by the das tags as long as it implements the Collections interface. To do so, just create an object using the jsp:useBean tag, or even (shudder) java scripting. Then reference it from any das:list tag for all the das coolness. Like so:

Similarly to the Simple List Use Case, in this simple example we create a map with a map tag and populate it with names and web-codes of some colors. That map is then used with the get tag to populate this drop down box with those color names and values.

One of the most important aspects of any given container, be that container physical, logical or even metaphorical, is the ability to retreive what which has previously been placed in that container. That is to say, of what use is a container if the items placed within that container cannot be retreived. Well, surely one could find a use for such a container, but then that container would very likely not be called a container in the first place but something else entirely since the very defining qualities that would have made it a container are not present within it.

But I digress...

In this instance, the instance of a map container within the das tag library, there are several ways through which one could retreive any given value. Following are several examples:

Via a das:get tag:

Via a keyed EL expression:

Via a das:get tag and an intermediary variable:

Via a looped das:get tag and an looping variable:

The following examples demonstrate removals. When you remove a mapping from a map container, that mapping is also retreived. So, you can either spew it out to the world, or shove it into a variable. If the mapping had more than one value associated with it ALL of the values will be removed using these methods.

Remove the mapping named "green" and write it to the output stream:

Remove the mapping named "purple" and shove it into a nice little variable:

The size of a map is determined to be the number of keys in that map. That count can be spewed directly to the output stream or stuffed into a variable. For example:

Here we will throw together a map that is sorted. Maps are sorted by key. This map we will sort in descending order. Since this sorting happens within the container itself, all other operations work the same way as if the map were not sorted.

Any external class can be referenced as a map from the das tags as long as it implements the Map interface. To do this, create an using the jsp:useBean tag. (You could do it from a Java script block if you really wanted, and you could sell drugs to school kids while you're at it.) Once that object is created by whatever faustian bargain you manage to obtain you can reference it from any das:map tag. Like so: