public  void configure(Configuration conf) throws ConfigurationException 
{
                      
        super.configure(conf);
        this.origConf = conf;
        this.origBadLinkStr = conf.getChild("bad-link-str").getValue(null);
        this.origInSchemes = conf.getChild("schemes").getValue("");
        this.origOutSchemes = conf.getChild("exclude-schemes").getValue("http https ftp news mailto");
        this.origNamespaceURI = conf.getChild("namespace-uri").getValue(NAMESPACE);
        /*
         * Setup origLinkAttrs map from the original Configuration:
         * 1. Parse link-attrs Configuration
         * 2. Process link-attr Children, warn if overwriting
         * 3. If no link-attrs, and no link-attr are available, defaults to "href"
         */
        String linkAttrsValue = conf.getChild("link-attrs").getValue("");
        this.origLinkAttrs = split(linkAttrsValue, " ", NO_REGEXP);
        Configuration[] attrConfs = conf.getChildren("link-attr");
        if (attrConfs.length  > 0) {
            RECompiler compiler = new RECompiler();
            for (int i = 0; i <  attrConfs.length; i++) {
                String attr = attrConfs[i].getAttribute("name");
                if (getLogger().isWarnEnabled() && origLinkAttrs.containsKey(attr)) {
                    getLogger().warn("Duplicate configuration entry found for attribute '" +
                                     attr + "', overwriting previous configuration");
                }
                String pattern = attrConfs[i].getAttribute("pattern", null);
                if (pattern == null) {
                    this.origLinkAttrs.put(attr, NO_REGEXP);
                } else {
                    try {
                        this.origLinkAttrs.put(attr, compiler.compile(pattern));
                    } catch (RESyntaxException e) {
                        String msg = "Invalid regexp pattern '" + pattern + "' specified for attribute '" + attr + "'";
                        throw new ConfigurationException(msg, attrConfs[i], e);
                    }
                }
            }
        }
        // If nothing configured, default to href attribute
        if (this.origLinkAttrs.size() == 0) {
            this.origLinkAttrs.put("href", NO_REGEXP);
        }
}

Configure this component from the map:transformer block. Called before initialization and setup.

 public  void dispose() 
{
        if (this.modHelper != null) {
            this.modHelper.releaseAll();
            this.modHelper = null;
        }
        super.dispose();
}

 public  void initialize() throws Exception 
{
        this.modHelper = new InputModuleHelper();
        this.modHelper.setup(this.manager);
}

Initiate resources prior to this component becoming active.

 public  void recycle() 
{
        // Note: configure() and initialize() are not called after every
        //       recycle, so don't null origConf, origLinkAttrs, etc.
        this.conf = null;
        this.badLinkStr = null;
        this.linkAttrs = null;
        this.inSchemes = null;
        this.outSchemes = null;
        super.recycle();
}

Recycle this component for use in another map:transform.

 public  void setup(SourceResolver resolver,
    Map objectModel,
    String src,
    Parameters parameters) throws IOException, SAXException, ProcessingException 
{
        super.setup(resolver, objectModel, src, parameters);
        this.badLinkStr = parameters.getParameter("bad-link-str",       // per-request config
                                                  this.origBadLinkStr); // else fall back to per-instance config
        this.namespaceURI = parameters.getParameter("namespace-uri", this.origNamespaceURI);
        this.inSchemes = split(parameters.getParameter("schemes", this.origInSchemes), " ");
        this.outSchemes = split(parameters.getParameter("exclude-schemes", this.origOutSchemes), " ");
        this.linkAttrs = this.origLinkAttrs;
        if (parameters.isParameter("link-attrs")) {
            try {
                this.linkAttrs = split(parameters.getParameter("link-attrs"), " ", NO_REGEXP);
            } catch (ParameterException ex) {
                // shouldn't happen
            }
        }
        if (getLogger().isDebugEnabled()) {
            getLogger().debug("bad-link-str = " + badLinkStr);
            getLogger().debug("link-attrs = " + linkAttrs);
            getLogger().debug("schemes = " + inSchemes);
            getLogger().debug("exclude-schemes = " + outSchemes);
            getLogger().debug("namespace-uri = " + namespaceURI);
        }
        // Generate conf
        VariableConfiguration varConf = new VariableConfiguration(this.origConf);
        varConf.addVariable("src", src);
        varConf.addVariables(parameters);
        try {
            this.conf = varConf.getConfiguration();
        } catch (ConfigurationException ce) {
            throw new ProcessingException("Couldn't create dynamic config ", ce);
        }
}

Setup this component to handle a map:transform instance.

 public  void startTransformingElement(String uri,
    String name,
    String raw,
    Attributes attr) throws IOException, SAXException, ProcessingException 
{
        boolean matched = false;
        for (int attrIdx = 0; attrIdx <  attr.getLength(); attrIdx++) {
            String attrName = attr.getQName(attrIdx);
            String attrValue = createTransformedAttr(attrName, attr.getValue(attrIdx));
            if (attrValue != null) {
                if (!matched) {
                    attr = new AttributesImpl(attr);
                    matched = true;
                }
                ((AttributesImpl) attr).setValue(attrIdx, attrValue);
            }
        }
        super.startTransformingElement(uri, name, raw, attr);
}

Start processing elements of our namespace. This hook is invoked for each sax event with our namespace.