|
|
Matchers and selectors are sitemap components. They are used to
determine the flow, the other components involved and their ordering
of the request processing. One particular matcher you're probably
familiar with, is the WildcardURIMatcher. That is the one that
determines the (sub-)pipeline in the welcome example. But there are
many more matchers supplied with Apache Cocoon, one matches the requested
URI on regular expressions, others match the client's hostname,
existence of parameters and so on.
There is also a number of selectors supplied with Cocoon. Selectors
test a generally simple boolean expression and allow to select on
roughly the same things as matchers would. There is a selector on
the client's hostname, on the client's browser etc.
To make things even more complicated, actions have very similar
properties. You can nest other sitemap elements in an action and
those are included in the processing only if the action completes
successfully.
|
 |  |  |
 | So what are the differences? |  |
 |  |  |
The basic structure of a selector is that of a case, switch or
if-elseif-...-elseif-else statement in programming languages while
matchers and actions compare more to a if statement. In addition
selectors don't communicate the basis for their decision to the
embedded elements, just select the next part(s) of the
pipeline. Matchers and actions, however, add a new map to the
environment that can be used for the further processing in the
sub pipeline.
You've already come across this feature on the example sitemap: The
value matched by the WildcardURIMatcher is used to determine the
filename docs/samples/xsp/{1}.xsp . Here {1}
represents the value that is stored in the environmental map with the
key 1 . The name of the key is arbitrary and set by the
matcher. If you had supplied a more complex pattern, there would be
others. For example <map:match pattern="*/*/*/*/report.html">
would result in keys 1 , 2 , 3 ,
and 4 being defined, corresponding to the * s
in the pattern.
BTW you cannot access those maps from your XSP. Use parameters to the
generator to explicitly send them. On your XSP you can access them
through an object called parameters . Example
 |  |  |
 |
<map:match pattern="*/*/*/*/report.html">
<map:generate type="serverpages" src="docs/getPostcodeData.xsp">
<parameter name="postcode" value="{1}{2} {3}{4}"/>
</map:generate>
<map:transform src="stylesheets/html/report.xsl"/>
<map:serialize/>
</map:match>
|  |
 |  |  |
On your XSP do
 |  |  |
 |
<xsp:expr>parameters.getParameter("postcode")</xsp:expr>
|  |
 |  |  |
Generally, one could say that selectors are better suited if the
decisions has few easily distinguishable cases, the map feature is not
needed and the decision occurs later in the pipeline. Their
implementation should be lightweight and so is their integration in
the compiled sitemap.
Matchers are often the very first element in a pipeline. They direct
the processing based on more complex decision process. They are
general purpose but more costly than selectors.
Actions should be used to "do" something, not to chose
between different sub pipelines. That should be done only, if an error
occurred and you cannot continue the regular pipeline. Of course this
is a fuzzy criterion and using an action to chose between exactly two
sub pipelines is a very common task i.e. for authentication. Also,
often actions have no nested elements and the further processing is
not affected by the result of the action.
|
 |  |  |
 | Write Your Own Matchers and Selectors |  |
 |  |  |
Since the basic structure and the assumptions are very similar, we
look first at matchers and matcher factories and point out the
differences to selectors at the end.
Matchers need to implement the org.apache.cocoon.matching.Matcher
interface. See javadocs for more details, see also example matchers
included in the distribution.
If you would like to do global configuration for your matcher, it has
to implement the
org.apache.avalon.framework.configuration.Configurable
interface.
Matcher factories generate two distinct parts of source code: a
processed pattern stored in a global variable in the sitemap and a
method used to do the actual matching. Since the global variable can
be of an arbitrary type and it is an argument for the matcher method,
it is, too, configurable.
For each uniquely named matcher the function
generateParameterSource and
generateMethodSource are called exactly once, while
generateClassSource is called for every use of the
generated matcher in sitemap pipelines.
Note that you may use the same matcher factory (or the same matcher or
whatever) and declare it with different names. Although they will be
instances of the very same class they would be different instances and
thus another matcher method would be generated, e.g. using different
configuration parameters.
The generated matcher method looks like
 |  |  |
 |
private Map wildcardMatch (int [] pattern, Map objectModel,
Parameters parameters) {
// this has been generated by generateMethodSource ->
HashMap map = new HashMap();
String uri = XSPRequestHelper.getSitemapURI(objectModel);
if (uri.startsWith("/"))
uri = uri.substring(1);
if (org.apache.cocoon.matching.helpers.WildcardURIMatcher.match (
map, uri, pattern)) {
return map;
} else {
return null;
}
// <- this has been generated by generateMethodSource
}
|  |
 |  |  |
The method takes three arguments: the first is the aforementioned by
generateClassSource processed pattern, the current environment
(objectModel ), and the parameters given for the corresponding match
element. In the example above for nested matchers, this would be the
<map:parameter name="attribute-name" value="__sessionstate"/> . The
int [] part of the method signature was generated by
generateParameterSource .
To configure the generated matcher, global configuration parameters
can be used to create different sources. To read global configuration
parameters, dom2 is used, you cannot use the usual avalon classes for
this.
Local configuration parameters are avalon parameters and thus can be
easily read and used with the generated matcher method.
If the matcher returns not null, the match was successful and the
nested sub pipeline is executed. Components in sub pipeline can access
the matching result through the returned map.
The easiest way to write your own matcher would be to base it upon
org.apache.cocoon.matching.WildcardURIMatcherFactory and override the
generateMethodSource method with your own.
Personally, I like factories more because they are easily written and
global configuration options can be incorporated in the generated
source thus the generated source is less complex than a similar
versatile matcher would be.
|
|
Selectors and selector factories differ from their matcher counter
parts only in the fact that selectors return boolean values rather
than maps. Thus when a selector returns true the nested
elements will be included in the processing, otherwise they are not
included. Since no map is returned, no additional information may be
passed to those elements.
For selectors, the last argument reads param instead of
parameters .
|
|
|
|