package net.sf.tomp.xtcl.filter;
   
   import net.sf.tomp.general.Parametrized;
   
   import org.apache.commons.logging.Log;
   import org.apache.commons.logging.LogFactory;
   import org.xml.sax.Attributes;
   import org.xml.sax.ContentHandler;
   import org.xml.sax.DTDHandler;
  import org.xml.sax.EntityResolver;
  import org.xml.sax.ErrorHandler;
  import org.xml.sax.InputSource;
  import org.xml.sax.Locator;
  import org.xml.sax.SAXException;
  import org.xml.sax.SAXNotRecognizedException;
  import org.xml.sax.SAXNotSupportedException;
  import org.xml.sax.SAXParseException;
  import org.xml.sax.XMLFilter;
  import org.xml.sax.XMLReader;
  import org.xml.sax.ext.LexicalHandler;
  
  import java.io.IOException;
  
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Properties;
  
  /***
   * DOCUMENT ME!
   * 
   * @author tomp
   */
  public class DynamicFilterImpl extends XTFilterImpl implements DynamicFilter {
  
      private Log log = LogFactory.getLog(DynamicFilterImpl.class);
  ////////////////////////////////////////////////////////////////////
      // Internal state.
      ////////////////////////////////////////////////////////////////////
  
      private Map params = new HashMap();
      
      /*** DOCUMENT ME! */
      protected XMLFilter filter = null;
  
      /*** DOCUMENT ME! */
      protected boolean isContentHandler;
  
      /*** DOCUMENT ME! */
      protected boolean isDTDHandler;
  
      /*** DOCUMENT ME! */
      protected boolean isErrorHandler;
  
      /*** DOCUMENT ME! */
      protected boolean isLexicalHandler;
  
      /*** DOCUMENT ME! */
      protected boolean isEntityResolver;
  
      /*** DOCUMENT ME! */
      protected HasOutputProperties outputPropertiesListener = null;
  
      ////////////////////////////////////////////////////////////////////
      // Constructors.
      ////////////////////////////////////////////////////////////////////
  
      /***
       * Construct an empty XML filter, with no parent.
       * <p>
       * This filter will have no parent: you must assign a parent before you
       * start a parse or do any configuration with setFeature or setProperty,
       * unless you use this as a pure event consumer rather than as an {@link
       * XMLReader}.
       * </p>
       * 
       * @see org.xml.sax.XMLReader#setFeature
       * @see org.xml.sax.XMLReader#setProperty
       * @see #setParent
       */
      public DynamicFilterImpl() {
          super();
  
          //setFilter(f);
      }
  
      /***
       * Construct an XML filter with the specified parent.
       * 
       * @param parent DOCUMENT ME!
       * @see #setParent
       * @see #getParent
       */
      public DynamicFilterImpl(XMLReader parent) {
          this();
          setParent(parent);
      }
  
      ////////////////////////////////////////////////////////////////////
     // Implementation of org.xml.sax.XMLFilter.
     ////////////////////////////////////////////////////////////////////
 
     /***
      * Set the parent reader.
      * <p>
      * This is the {@link org.xml.sax.XMLReader XMLReader}from which this
      * filter will obtain its events and to which it will pass its configuration
      * requests. The parent may itself be another filter.
      * </p>
      * <p>
      * If there is no parent reader set, any attempt to parse or to set or get a
      * feature or property will fail.
      * </p>
      * 
      * @param parent The parent XML reader.
      * @see #getParent
      */
     public void setParent(XMLReader parent) {
         super.setParent(parent);
 
         //System.out.println(" ***DynamicFilterImpl:"+this+"
         // setParent="+parent+"... ");
         if (filter != null) {
             filter.setParent(parent);
 
             //System.out.println("... also to filter="+filter);
         }
     }
 
     ////////////////////////////////////////////////////////////////////
     // Implementation of org.xml.sax.XMLReader.
     ////////////////////////////////////////////////////////////////////
 
     /***
      * Set the value of a feature.
      * <p>
      * This will always fail if the parent is null.
      * </p>
      * 
      * @param name The feature name.
      * @param value The requested feature value.
      * @exception SAXNotRecognizedException If the feature value can't be
      *                assigned or retrieved from the parent.
      * @exception SAXNotSupportedException When the parent recognizes the
      *                feature name but cannot set the requested value.
      */
     public void setFeature(String name, boolean value)
             throws SAXNotRecognizedException, SAXNotSupportedException {
         if (filter != null) {
             filter.setFeature(name, value);
         }
 
         super.setFeature(name, value);
     }
 
     /***
      * Look up the value of a feature.
      * <p>
      * This will always fail if the parent is null.
      * </p>
      * 
      * @param name The feature name.
      * @return The current value of the feature.
      * @exception SAXNotRecognizedException If the feature value can't be
      *                assigned or retrieved from the parent.
      * @exception SAXNotSupportedException When the parent recognizes the
      *                feature name but cannot determine its value at this time.
      */
     public boolean getFeature(String name) throws SAXNotRecognizedException,
             SAXNotSupportedException {
         if (filter != null) {
             return filter.getFeature(name);
         } else {
             return super.getFeature(name);
         }
     }
 
     /***
      * Set the value of a property.
      * <p>
      * This will always fail if the parent is null.
      * </p>
      * 
      * @param name The property name.
      * @param value The requested property value.
      * @exception SAXNotRecognizedException If the property value can't be
      *                assigned or retrieved from the parent.
      * @exception SAXNotSupportedException When the parent recognizes the
      *                property name but cannot set the requested value.
      */
     public void setProperty(String name, Object value)
             throws SAXNotRecognizedException, SAXNotSupportedException {
         if (filter != null) {
             filter.setProperty(name, value);
         }
 
         super.setProperty(name, value);
     }
 
     /***
      * Look up the value of a property.
      * 
      * @param name The property name.
      * @return The current value of the property.
      * @exception SAXNotRecognizedException If the property value can't be
      *                assigned or retrieved from the parent.
      * @exception SAXNotSupportedException When the parent recognizes the
      *                property name but cannot determine its value at this time.
      */
     public Object getProperty(String name) throws SAXNotRecognizedException,
             SAXNotSupportedException {
         if (filter != null) {
             return filter.getProperty(name);
         } else {
             return super.getProperty(name);
         }
     }
 
     /***
      * Set the entity resolver.
      * 
      * @param resolver The new entity resolver.
      */
 //    comm out by TP  Oct 5 2004
 /*    public void setEntityResolver(EntityResolver resolver) {
         
 //        log.info("setEntityResolver="+resolver);
         
         if (filter != null) {
             filter.setEntityResolver(resolver);
         }
 
         super.setEntityResolver(resolver);
     }
 */
     /***
      * Get the current entity resolver.
      * 
      * @return The current entity resolver, or null if none was set.
      */
     public EntityResolver getEntityResolver() {
         if (filter != null) {
             return filter.getEntityResolver();
         } else {
             return super.getEntityResolver();
         }
     }
 
     /***
      * Set the DTD event handler.
      * 
      * @param handler The new DTD handler.
      */
     public void setDTDHandler(DTDHandler handler) {
         if (filter != null) {
             filter.setDTDHandler(handler);
         }
 
         super.setDTDHandler(handler);
     }
 
     /***
      * Get the current DTD event handler.
      * 
      * @return The current DTD handler, or null if none was set.
      */
     public DTDHandler getDTDHandler() {
         if (filter != null) {
             return filter.getDTDHandler();
         } else {
             return super.getDTDHandler();
         }
     }
 
     /***
      * Set the content event handler.
      * 
      * @param handler The new content handler.
      */
     public void setContentHandler(ContentHandler handler) {
         //System.out.println(""+this+".setContentHandler="+handler);
         if (filter != null) {
             filter.setContentHandler(handler);
         }
 
         super.setContentHandler(handler);
     }
 
     /***
      * Get the content event handler.
      * 
      * @return The current content handler, or null if none was set.
      */
     public ContentHandler getContentHandler() {
         //System.out.println(""+this+".getContentHandler=>"+contentHandler);
         if (filter != null) {
             return filter.getContentHandler();
         } else {
             return super.getContentHandler();
         }
     }
 
     /***
      * Set the lexical event handler.
      * 
      * @param handler The new lexical handler.
      */
     public void setLexicalHandler(LexicalHandler handler) {
         //System.out.println(""+this+".setContentHandler="+handler);
         lexicalHandler = handler;
     }
 
     /***
      * Get the lexical event handler.
      * 
      * @return The current lexical handler, or null if none was set.
      */
     public LexicalHandler getLexicalHandler() {
         //System.out.println(""+this+".getContentHandler=>"+contentHandler);
         return lexicalHandler;
     }
 
     /***
      * Set the error event handler.
      * 
      * @param handler The new error handler.
      */
     public void setErrorHandler(ErrorHandler handler) {
         if (filter != null) {
             filter.setErrorHandler(handler);
         }
 
         super.setErrorHandler(handler);
     }
 
     /***
      * Get the current error event handler.
      * 
      * @return The current error handler, or null if none was set.
      */
     public ErrorHandler getErrorHandler() {
         if (filter != null) {
             return filter.getErrorHandler();
         } else {
             return super.getErrorHandler();
         }
     }
 
     /***
      * Parse a document.
      * 
      * @param input The input source for the document entity.
      * @exception SAXException Any SAX exception, possibly wrapping another
      *                exception.
      * @exception IOException An IO exception from the parser, possibly from a
      *                byte stream or character stream supplied by the
      *                application.
      */
     public void parse(InputSource input) throws SAXException, IOException {
         if (filter != null) {
             filter.parse(input);
         } else {
             super.parse(input);
         }
     }
 
     ////////////////////////////////////////////////////////////////////
     // Implementation of org.xml.sax.EntityResolver.
     ////////////////////////////////////////////////////////////////////
 
     /***
      * Filter an external entity resolution.
      * 
      * @param publicId The entity's public identifier, or null.
      * @param systemId The entity's system identifier.
      * @return A new InputSource or null for the default.
      * @exception SAXException The client may throw an exception during
      *                processing.
      * @exception IOException The client may throw an I/O-related exception
      *                while obtaining the new InputSource.
      */
     public InputSource resolveEntity(String publicId, String systemId)
             throws SAXException, IOException {
 //        System.out.println(toString()+"try to resolveEntity="+systemId);
         if ((filter != null) && isEntityResolver) {
             return ((EntityResolver) filter).resolveEntity(publicId, systemId);
         } else {
             return super.resolveEntity(publicId, systemId);
         }
     }
 
     ////////////////////////////////////////////////////////////////////
     // Implementation of org.xml.sax.DTDHandler.
     ////////////////////////////////////////////////////////////////////
 
     /***
      * Filter a notation declaration event.
      * 
      * @param name The notation name.
      * @param publicId The notation's public identifier, or null.
      * @param systemId The notation's system identifier, or null.
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void notationDecl(String name, String publicId, String systemId)
             throws SAXException {
         if (filter != null) {
             if (isDTDHandler) {
                 ((DTDHandler) filter).notationDecl(name, publicId, systemId);
             } else {
                 super.notationDecl(name, publicId, systemId);
             }
         }
     }
 
     /***
      * Filter an unparsed entity declaration event.
      * 
      * @param name The entity name.
      * @param publicId The entity's public identifier, or null.
      * @param systemId The entity's system identifier, or null.
      * @param notationName The name of the associated notation.
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void unparsedEntityDecl(String name, String publicId,
             String systemId, String notationName) throws SAXException {
         if (filter != null) {
             if (isDTDHandler) {
                 ((DTDHandler) filter).unparsedEntityDecl(name, publicId,
                         systemId, notationName);
             }
         } else {
             super.unparsedEntityDecl(name, publicId, systemId, notationName);
         }
     }
 
     ////////////////////////////////////////////////////////////////////
     // Implementation of org.xml.sax.ContentHandler.
     ////////////////////////////////////////////////////////////////////
 
     /***
      * Filter a new document locator event.
      * 
      * @param locator The document locator.
      */
     public void setDocumentLocator(Locator locator) {
         if (filter != null) {
             if (isContentHandler) {
                 ((ContentHandler) filter).setDocumentLocator(locator);
             }
         }
 
         super.setDocumentLocator(locator);
     }
 
     /***
      * Filter a start document event.
      * 
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void startDocument() throws SAXException {
         //System.out.println(""+this+".startDocument");
         if (filter != null) {
             if (isContentHandler) {
                 //((ContentHandler)filter).setDocumentLocator(locator);
                 ((ContentHandler) filter).startDocument();
             }
         } else {
             super.startDocument();
         }
 
         if (outputPropertiesListener != null) {
             outputPropertiesListener.setOutputProperties(getOutputProperties());
         }
     }
 
     /***
      * Filter an end document event.
      * 
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void endDocument() throws SAXException {
         //System.out.println("---DynamicFilter "+this+".endDocument,
         // filter="+filter);
         if (filter != null) {
             //System.out.println("---filter has
             // contenthandler="+filter.getContentHandler());
             if (isContentHandler) {
                 ((ContentHandler) filter).endDocument();
             }
         } else {
             super.endDocument();
         }
     }
 
     /***
      * Filter a start Namespace prefix mapping event.
      * 
      * @param prefix The Namespace prefix.
      * @param uri The Namespace URI.
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void startPrefixMapping(String prefix, String uri)
             throws SAXException {
         if (filter != null) {
             if (isContentHandler) {
                 ((ContentHandler) filter).startPrefixMapping(prefix, uri);
             }
         } else {
             super.startPrefixMapping(prefix, uri);
         }
     }
 
     /***
      * Filter an end Namespace prefix mapping event.
      * 
      * @param prefix The Namespace prefix.
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void endPrefixMapping(String prefix) throws SAXException {
         if (filter != null) {
             if (isContentHandler) {
                 ((ContentHandler) filter).endPrefixMapping(prefix);
             }
         } else {
             super.endPrefixMapping(prefix);
         }
     }
 
     /***
      * Filter a start element event.
      * 
      * @param uri The element's Namespace URI, or the empty string.
      * @param localName The element's local name, or the empty string.
      * @param qName The element's qualified (prefixed) name, or the empty
      *            string.
      * @param atts The element's attributes.
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void startElement(String uri, String localName, String qName,
             Attributes atts) throws SAXException {
         if (filter != null) {
             if (isContentHandler) {
                 ((ContentHandler) filter).startElement(uri, localName, qName,
                         atts);
             }
         } else {
             super.startElement(uri, localName, qName, atts);
         }
     }
 
     /***
      * Filter an end element event.
      * 
      * @param uri The element's Namespace URI, or the empty string.
      * @param localName The element's local name, or the empty string.
      * @param qName The element's qualified (prefixed) name, or the empty
      *            string.
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void endElement(String uri, String localName, String qName)
             throws SAXException {
         if (filter != null) {
             if (isContentHandler) {
                 ((ContentHandler) filter).endElement(uri, localName, qName);
             }
         } else {
             super.endElement(uri, localName, qName);
         }
     }
 
     /***
      * Filter a character data event.
      * 
      * @param ch An array of characters.
      * @param start The starting position in the array.
      * @param length The number of characters to use from the array.
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void characters(char[] ch, int start, int length)
             throws SAXException {
         if (filter != null) {
             if (isContentHandler) {
                 ((ContentHandler) filter).characters(ch, start, length);
             }
         } else {
             super.characters(ch, start, length);
         }
     }
 
     /***
      * Filter an ignorable whitespace event.
      * 
      * @param ch An array of characters.
      * @param start The starting position in the array.
      * @param length The number of characters to use from the array.
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void ignorableWhitespace(char[] ch, int start, int length)
             throws SAXException {
         if (filter != null) {
             if (isContentHandler) {
                 ((ContentHandler) filter)
                         .ignorableWhitespace(ch, start, length);
             }
         } else {
             super.ignorableWhitespace(ch, start, length);
         }
     }
 
     /***
      * Filter a processing instruction event.
      * 
      * @param target The processing instruction target.
      * @param data The text following the target.
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void processingInstruction(String target, String data)
             throws SAXException {
         if (filter != null) {
             if (isContentHandler) {
                 ((ContentHandler) filter).processingInstruction(target, data);
             }
         } else {
             super.processingInstruction(target, data);
         }
     }
 
     /***
      * Filter a skipped entity event.
      * 
      * @param name The name of the skipped entity.
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void skippedEntity(String name) throws SAXException {
         if (filter != null) {
             if (isContentHandler) {
                 ((ContentHandler) filter).skippedEntity(name);
             }
         } else {
             super.skippedEntity(name);
         }
     }
 
     ////////////////////////////////////////////////////////////////////
     // Implementation of org.xml.sax.ErrorHandler.
     ////////////////////////////////////////////////////////////////////
 
     /***
      * Filter a warning event.
      * 
      * @param e The warning as an exception.
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void warning(SAXParseException e) throws SAXException {
         if (filter != null) {
             if (isErrorHandler) {
                 ((ErrorHandler) filter).warning(e);
             }
         } else {
             super.warning(e);
         }
     }
 
     /***
      * Filter an error event.
      * 
      * @param e The error as an exception.
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void error(SAXParseException e) throws SAXException {
         if (filter != null) {
             if (isErrorHandler) {
                 ((ErrorHandler) filter).error(e);
             }
         } else {
             super.error(e);
         }
     }
 
     /***
      * Filter a fatal error event.
      * 
      * @param e The error as an exception.
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void fatalError(SAXParseException e) throws SAXException {
         if (filter != null) {
             if (isErrorHandler) {
                 ((ErrorHandler) filter).fatalError(e);
             }
         } else {
             super.fatalError(e);
         }
     }
 
     ////////////////////////////////////////////////////////////////////
     // Implementation of the LexicalHandler.
     ////////////////////////////////////////////////////////////////////
 
     /***
      * Callback interface for SAX (part of LexicalHandler interface): not for
      * application use
      * 
      * @param ch DOCUMENT ME!
      * @param start DOCUMENT ME!
      * @param length DOCUMENT ME!
      * @throws SAXException DOCUMENT ME!
      */
     public void comment(char[] ch, int start, int length) throws SAXException {
         if (filter != null) {
             if (isLexicalHandler) {
                 ((LexicalHandler) filter).comment(ch, start, length);
             }
         } else {
             super.comment(ch, start, length);
         }
     }
 
     // No-op methods to satisfy lexical handler interface
 
     /***
      * Register the start of the DTD. Comments in the DTD are skipped because
      * they are not part of the XPath data model
      * 
      * @param name DOCUMENT ME!
      * @param publicId DOCUMENT ME!
      * @param systemId DOCUMENT ME!
      * @throws SAXException DOCUMENT ME!
      */
     public void startDTD(String name, String publicId, String systemId)
             throws SAXException {
         if (filter != null) {
             if (isLexicalHandler) {
                 ((LexicalHandler) filter).startDTD(name, publicId, systemId);
             }
         } else {
             super.startDTD(name, publicId, systemId);
         }
     }
 
     /***
      * Register the end of the DTD. Comments in the DTD are skipped because they
      * are not part of the XPath data model
      * 
      * @throws SAXException DOCUMENT ME!
      */
     public void endDTD() throws SAXException {
         if (filter != null) {
             if (isLexicalHandler) {
                 ((LexicalHandler) filter).endDTD();
             }
         } else {
             super.endDTD();
         }
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @param name DOCUMENT ME!
      * @throws SAXException DOCUMENT ME!
      */
     public void startEntity(String name) throws SAXException {
         if (filter != null) {
             if (isLexicalHandler) {
                 ((LexicalHandler) filter).startEntity(name);
             }
         } else {
             super.startEntity(name);
         }
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @param name DOCUMENT ME!
      * @throws SAXException DOCUMENT ME!
      */
     public void endEntity(String name) throws SAXException {
         if (filter != null) {
             if (isLexicalHandler) {
                 ((LexicalHandler) filter).endEntity(name);
             }
         } else {
             super.endEntity(name);
         }
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @throws SAXException DOCUMENT ME!
      */
     public void startCDATA() throws SAXException {
         if (filter != null) {
             if (isLexicalHandler) {
                 ((LexicalHandler) filter).startCDATA();
             }
         } else {
             super.startCDATA();
         }
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @throws SAXException DOCUMENT ME!
      */
     public void endCDATA() throws SAXException {
         if (filter != null) {
             if (isLexicalHandler) {
                 ((LexicalHandler) filter).endCDATA();
             }
         } else {
             super.endCDATA();
         }
     }
 
     ////////////////////////////////////////////////////////////////////
     // Internal methods.
     ////////////////////////////////////////////////////////////////////
     public void setFilter(XMLFilter f) throws SAXException {
         isContentHandler = f instanceof ContentHandler;
         isDTDHandler = f instanceof DTDHandler;
         isErrorHandler = f instanceof ErrorHandler;
         isLexicalHandler = f instanceof LexicalHandler;
         isEntityResolver = f instanceof EntityResolver;
 
         //System.out.println(this+" *** DynamicFilterImpl: SETS FILTER to "+f+"
         // parent is "+getParent());
         if (f != null) {
             XMLReader parent = getParent();
 
             // route messages from parent to filter
             //System.out.println(parent+" *** SETS HANDLERS to "+f);
 //            if (isEntityResolver) {
 //                parent.setEntityResolver((EntityResolver) f);
 //            }
 
             if (isDTDHandler) {
                 parent.setDTDHandler((DTDHandler) f);
             }
 
             if (isContentHandler) {
                 parent.setContentHandler((ContentHandler) f);
             }
 
             if (isErrorHandler) {
                 parent.setErrorHandler((ErrorHandler) f);
             }
 
             if (isLexicalHandler) {
                 parent.setProperty(
                         "http://xml.org/sax/properties/lexical-handler", f);
             }
 
             // route messages from filter to further handlers
             //System.out.println(f+" *** SETS DTD HANDLER to
             // "+getDTDHandler());
             ContentHandler ch = getContentHandler();
 
             if (ch != null) {
                 f.setContentHandler(ch);
             }
 
             DTDHandler dh = getDTDHandler();
 
             if (dh != null) {
                 f.setDTDHandler(dh);
             }
 
 /*            EntityResolver er = getEntityResolver();
 
             if (er != null) {
                 f.setEntityResolver(er);
             }
 */
             ErrorHandler eh = getErrorHandler();
 
             if (eh != null) {
                 f.setErrorHandler(eh);
             }
 
             Object lh = getProperty("http://xml.org/sax/properties/lexical-handler");
 
             try {
                 if (lh != null) {
                     f
                             .setProperty(
                                     "http://xml.org/sax/properties/lexical-handler",
                                     lh);
                 }
             } catch (SAXException se) {
             }
             
             propagateParamsToFilter(f);
 
             // connect to parent
             f.setParent(parent);
 
             // plug filter in
             filter = f;
         }
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @return DOCUMENT ME!
      */
     public XMLFilter getFilter() {
         return filter;
     }
 
     public void setParameter(String k, Object v) {
         //System.out.println("Setting param "+k+"="+v);
 //        comm out by TP Oct 3 2004,
 //        params need to be stored and passed to filter
 //        when it is set by calling setFilter!
         
 /*        if(filter != null && filter instanceof Parametrized) {
             ((Parametrized)filter).setParameter(k, v);
         }
 */  
 //        store params for later setting to filter
         params.put(k, v);
     }
     
     protected void propagateParamsToFilter(XMLFilter filter) {
         if(filter != null && filter instanceof Parametrized) {
             Parametrized pf = (Parametrized)filter;
             for(Iterator i = params.entrySet().iterator(); i.hasNext();) {
                 Map.Entry me = (Map.Entry)i.next();
 //                log.info("propagating param "+me.getKey()+ "="+me.getValue()+" to "+pf);
                 pf.setParameter((String)me.getKey(), me.getValue());
             }
         }
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @return DOCUMENT ME!
      */
     public Properties getOutputProperties() {
         //System.out.println(this+" +++++++++++++ getOutputProperties from
         // filter=" + filter);
         if (filter instanceof HasOutputProperties) {
             return ((HasOutputProperties) filter).getOutputProperties();
         }
 
         return null;
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @param p DOCUMENT ME!
      * @throws UnsupportedOperationException DOCUMENT ME!
      */
     public void setOutputProperties(Properties p) {
         throw new UnsupportedOperationException(
                 "Cannot setOutputProperties on " + this);
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @param l DOCUMENT ME!
      */
     public void setOutputPropertiesListener(HasOutputProperties l) {
         outputPropertiesListener = l;
     }
 }
 
 /*
  * The contents of this file are subject to the Mozilla Public License Version
  * 1.1 (the "License"); you may not use this file except in compliance with the
  * License. You may obtain a copy of the License at http://www.mozilla.org/MPL/
  * Software distributed under the License is distributed on an "AS IS" basis,
  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
  * the specific language governing rights and limitations under the License. The
  * Original Code is: all this file. The Initial Developer of the Original Code
  * is: Tomas Pitner, Masaryk University in Brno, Czech Republic. Contributor(s):
  */