public  void endElement(String uri,
    String name,
    String raw) throws SAXException 
{
        String query;
        if (name.equals(QUERY_TAG) && uri.equals(DASL_QUERY_NS)) {
            DocumentFragment frag = this.endRecording();
            try {
                Properties props = XMLUtils.createPropertiesForXML(false);
                props.put(OutputKeys.ENCODING, "ISO-8859-1");
                query = XMLUtils.serializeNode(frag, props);
                // Perform the DASL query
                this.performSearchMethod(query);
            } catch (ProcessingException e) {
                throw new SAXException("Unable to fetch the query data:", e);
            }
        } else if (name.equals(SUBSTITUTE_TAG) && uri.equals(DASL_QUERY_NS)) {
            //Do nothing!!!!
        } else {
            super.endElement(uri, name, raw);
        }
}

Intercept the end tag, convert buffered input to a String, build and execute the DASL query.

 public Serializable getKey() 
{
		if(this.parameters.getNames().length == 0) {
			return getClass().getName();
		} else {
			StringBuffer buf = new StringBuffer();
			buf.append(getClass().getName());
			// important for substitution
			// we don't know yet which ones are relevant, so include all
			String[] names = this.parameters.getNames();
			for(int i=0; i< names.length; i++) {
				buf.append(";");
				buf.append(names[i]);
				buf.append("=");
				try {
					buf.append(this.parameters.getParameter(names[i]));
				} catch (Exception e) {
					if(getLogger().isErrorEnabled())
		    			getLogger().error("Could not read parameter '"+names[i]+"'!",e);
				}
			}
			return buf.toString();
		}
}

generates the cachekey, which is the classname plus any possible COCOON parameters

 public SourceValidity getValidity() 
{
		if(getLogger().isDebugEnabled())
			getLogger().debug("getValidity() called!");
		// dont do any caching when no event caching is set up
		if (m_eventfactory == null) {
			return null;
		}
        if (m_validity == null) {
            m_validity = new AggregatedValidity();
        }
        return m_validity;
}

returns the validity which will be filled during processing of the requests

 protected  void performSearchMethod(String query) throws SAXException 
{
    	OptionsMethod optionsMethod = null;
    	SearchMethod searchMethod = null;
        try {
            DOMStreamer propertyStreamer = new DOMStreamer(this.xmlConsumer);
            optionsMethod = new OptionsMethod(this.targetUrl);
            searchMethod = new SearchMethod(this.targetUrl, query);
            HttpURL url = new HttpURL(this.targetUrl);
            HttpState state = new HttpState();
            state.setCredentials(null, new UsernamePasswordCredentials(
                    url.getUser(),
                    url.getPassword()));
            HttpConnection conn = new HttpConnection(url.getHost(), url.getPort());
            // eventcaching stuff
            SourceValidity extraValidity = makeWebdavEventValidity(url);
            if(extraValidity!=null && m_validity!=null)
            	m_validity.add(extraValidity);
            // end eventcaching stuff
            WebdavResource resource = new WebdavResource(new HttpURL(this.targetUrl));
            if(!resource.exists()) {
                throw new SAXException("The WebDAV resource don't exist");
            }
            optionsMethod.execute(state, conn);
            if(!optionsMethod.isAllowed("SEARCH")) {
                throw new SAXException("The server doesn't support the SEARCH method");
            }
            int httpstatus = searchMethod.execute(state, conn);
            this.contentHandler.startElement(DASL_QUERY_NS,
                                             RESULT_ROOT_TAG,
                                             PREFIX + ":" + RESULT_ROOT_TAG,
                                             XMLUtils.EMPTY_ATTRIBUTES);
            // something might have gone wrong, report it
            // 207 = multistatus webdav response
            if(httpstatus != 207) {
            	this.contentHandler.startElement(DASL_QUERY_NS,
                        ERROR_ROOT_TAG,
                        PREFIX + ":" + ERROR_ROOT_TAG,
                        XMLUtils.EMPTY_ATTRIBUTES);
            	// dump whatever the server said
            	propertyStreamer.stream(searchMethod.getResponseDocument());
            	this.contentHandler.endElement(DASL_QUERY_NS,
            			ERROR_ROOT_TAG,
                        PREFIX + ":" + ERROR_ROOT_TAG);
            } else {
            	// show results
            	Enumeration enumeration = searchMethod.getAllResponseURLs();
	            while (enumeration.hasMoreElements()) {
	                String path = (String) enumeration.nextElement();
	                Enumeration properties = searchMethod.getResponseProperties(path);
	                AttributesImpl attr = new AttributesImpl();
	                attr.addAttribute(DASL_QUERY_NS, PATH_NODE_NAME, PREFIX + ":" + PATH_NODE_NAME, "CDATA",path);
	                this.contentHandler.startElement(DASL_QUERY_NS,
	                    RESOURCE_NODE_NAME,
	                    PREFIX + ":" + RESOURCE_NODE_NAME,
	                    attr);
	                while(properties.hasMoreElements()) {
	                    BaseProperty metadata = (BaseProperty) properties.nextElement();
	                    Element propertyElement = metadata.getElement();
	                    propertyStreamer.stream(propertyElement);
	                }
	                this.contentHandler.endElement(DASL_QUERY_NS,
	                    RESOURCE_NODE_NAME,
	                    PREFIX + ":" + RESOURCE_NODE_NAME);
	            }
            }
            this.contentHandler.endElement(DASL_QUERY_NS,
                                           RESULT_ROOT_TAG,
                                           PREFIX + ":" + RESULT_ROOT_TAG);
        } catch (SAXException e) {
            throw new SAXException("Unable to fetch the query data:", e);
        } catch (HttpException e1) {
            this.getLogger().error("Unable to contact Webdav server", e1);
            throw new SAXException("Unable to connect with server: ", e1);
        } catch (IOException e2) {
            throw new SAXException("Unable to connect with server: ", e2);
        } catch (NullPointerException e) {
            throw new SAXException("Unable to fetch the query data:", e);
        } catch (Exception e) {
            throw new SAXException("Generic Error:", e);
        } finally {
        	// cleanup
        	if(searchMethod!=null)
        		searchMethod.releaseConnection();
        	if(optionsMethod!=null)
        		optionsMethod.releaseConnection();
        }
}

 public  void recycle() 
{
    	super.recycle();
    	m_validity = null;
}

Forget about previous aggregated validity object

 public  void setup(SourceResolver resolver,
    Map objectModel,
    String src,
    Parameters par) throws IOException, SAXException, ProcessingException 
{
    	super.setup(resolver, objectModel, src, par);
    	if(m_eventfactory == null) {
    		try {
    			m_eventfactory = (WebDAVEventFactory)manager.lookup(WebDAVEventFactory.ROLE);
    		} catch (Exception e) {
    			if(getLogger().isErrorEnabled())
    				getLogger().error("Couldn't look up WebDAVEventFactory, event caching will not work!", e);
			}
    	}
}

 public  void startElement(String uri,
    String name,
    String raw,
    Attributes attr) throws SAXException 
{
	
        if (name.equals(QUERY_TAG) && uri.equals(DASL_QUERY_NS)) {
            this.startRecording();
            if ((targetUrl = attr.getValue(TARGET_URL)) == null) {
                throw new IllegalStateException("The query element must contain a \"target\" attribute");
            }
            //Sanityze target
            if (targetUrl.startsWith(WEBDAV_SCHEME))
                targetUrl =
                    "http://" + targetUrl.substring(WEBDAV_SCHEME.length());
            if (!targetUrl.startsWith("http"))
                throw new SAXException("Illegal value for target, must be an http:// or webdav:// URL");
        } else if (name.equals(SUBSTITUTE_TAG) && uri.equals(DASL_QUERY_NS)) {
            String parName = attr.getValue( DASL_QUERY_NS, SUBSTITUTE_TAG_NAME_ATTRIBUTE );
            if ( parName == null ) {
                throw new IllegalStateException( "Substitute value elements must have a " +
                                           SUBSTITUTE_TAG_NAME_ATTRIBUTE + " attribute" );
            }
            String substitute = this.parameters.getParameter( parName, null );
            if (getLogger().isDebugEnabled()) {
                getLogger().debug( "SUBSTITUTE VALUE " + substitute );
            }
            super.characters(substitute.toCharArray(), 0, substitute.length());
        } else {
            super.startElement(uri, name, raw, attr);
        }
}

Intercept the start tag.