public SourceWritingTransformer() 
{
             
        this.defaultNamespaceURI = SWT_URI;
}

Constructor. Set the namespace.

 public  void configure(Configuration configuration) throws ConfigurationException 
{
        super.configure(configuration);
        this.configuredSerializerName = configuration.getChild(SERIALIZER_ATTRIBUTE).getValue(DEFAULT_SERIALIZER);
}

Get the current Configuration instance used by this Configurable.

 public  void dispose() 
{
        if (this.manager != null) {
            this.manager.release(this.xpathProcessor);
            this.xpathProcessor = null;
        }
        super.dispose();
}

 public  void endTransformingElement(String uri,
    String name,
    String raw) throws IOException, SAXException, ProcessingException 
{
        if (getLogger().isDebugEnabled()) {
            getLogger().debug("End transforming element. uri=" + uri +
                              ", name=" + name + ", raw=" + raw);
        }
        if ((name.equals(INSERT_ELEMENT) && this.state == STATE_INSERT)
            || (name.equals(WRITE_ELEMENT) && this.state == STATE_WRITE)) {
            // get the information from the stack
            DocumentFragment fragment  = null;
            String tag;
            String sourceName    = null;
            String path        = (this.state == STATE_INSERT ? null : "/");
                                 // source:write's path can be empty
            String replacePath = null;
            String reinsert    = null;
            do {
                tag = (String)this.stack.pop();
                if (tag.equals("PATH")) {
                    path = (String)this.stack.pop();
                } else if (tag.equals("FILE")) {
                    sourceName = (String)this.stack.pop();
                } else if (tag.equals("FRAGMENT")) {
                    fragment = (DocumentFragment)this.stack.pop();
                } else if (tag.equals("REPLACE")) {
                    replacePath = (String)this.stack.pop();
                } else if (tag.equals("REINSERT")) {
                    reinsert = (String)this.stack.pop();
                }
            } while ( !tag.equals("END") );
            final String localSerializer = (String)this.stack.pop();
            final boolean overwrite = this.stack.pop().equals("true");
            final boolean create = this.stack.pop().equals("true");
            this.insertFragment(sourceName,
                                    path,
                                    fragment,
                                    replacePath,
                                    create,
                                    overwrite,
                                    reinsert,
                                    localSerializer,
                                    name);
            this.state = STATE_OUTSIDE;
        // Element: delete
        } else if (name.equals(DELETE_ELEMENT) && this.state == STATE_DELETE) {
            String sourceName = null;
            String tag;
            do {
                tag = (String)this.stack.pop();
                if (tag.equals("FILE")) {
                    sourceName = (String)this.stack.pop();
                } else if (tag.equals("FRAGMENT")) {
                    //Get rid of it
                    this.stack.pop();
                }
            } while ( !tag.equals("END"));
            this.deleteSource(sourceName);
            this.state = STATE_OUTSIDE;
        // Element: file
        } else if (name.equals(SOURCE_ELEMENT) && this.state == STATE_FILE) {
            this.state = this.parent_state;
            this.stack.push(this.endTextRecording());
            this.stack.push("FILE");
        // Element: path
        } else if (name.equals(PATH_ELEMENT) && this.state == STATE_PATH) {
            this.state = this.parent_state;
            this.stack.push(this.endTextRecording());
            this.stack.push("PATH");
        // Element: replace
        } else if (name.equals(REPLACE_ELEMENT) && this.state == STATE_REPLACE) {
            this.state = this.parent_state;
            this.stack.push(this.endTextRecording());
            this.stack.push("REPLACE");
        // Element: fragment
        } else if (name.equals(FRAGMENT_ELEMENT) && this.state == STATE_FRAGMENT) {
            this.state = this.parent_state;
            this.stack.push(this.endRecording());
            this.stack.push("FRAGMENT");
        // Element: reinsert
        } else if (name.equals(REINSERT_ELEMENT) && this.state == STATE_REINSERT) {
            this.state = this.parent_state;
            this.stack.push(this.endTextRecording());
            this.stack.push("REINSERT");
        // default
        } else {
            super.endTransformingElement(uri, name, raw);
        }
}

Receive notification of the end of an element.

 protected  void insertFragment(String systemID,
    String path,
    DocumentFragment fragment,
    String replacePath,
    boolean create,
    boolean overwrite,
    String reinsertPath,
    String localSerializer,
    String tagname) throws IOException, SAXException, ProcessingException 
{
        // no sync req
        if (getLogger().isDebugEnabled()) {
            getLogger().debug("Insert fragment. systemID=" + systemID +
                              ", path=" + path +
                              ", replace=" + replacePath +
                              ", create=" + create +
                              ", overwrite=" + overwrite +
                              ", reinsert=" + reinsertPath +
                              ", fragment=" + (fragment == null ? "null" : XMLUtils.serializeNode(fragment)));
        }
        // test parameter
        if (systemID == null) {
            throw new ProcessingException("insertFragment: systemID is required.");
        }
        if (path == null) {
            throw new ProcessingException("insertFragment: path is required.");
        }
        if (path.startsWith("/")) {
            path = path.substring(1);
        }
        if (fragment == null) {
            throw new ProcessingException("insertFragment: fragment is required.");
        }
        // first: read the source as a DOM
        Source source = null;
        Document resource = null;
        boolean failed = true;
        boolean exists = false;
        String message = "";
        String target = systemID;
        try {
            source = this.resolver.resolveURI(systemID);
            if (! (source instanceof ModifiableSource)) {
                throw new ProcessingException("Source '" + systemID + "' is not writeable.");
            }
            ModifiableSource ws = (ModifiableSource) source;
            exists = ws.exists();
            target = source.getURI();
            // Insert?
            if (exists && this.state == STATE_INSERT) {
                message = "content inserted at: " + path;
                resource = SourceUtil.toDOM(source);
                // import the fragment
                Node importNode = resource.importNode(fragment, true);
                // get the node
                Node parent = DOMUtil.selectSingleNode(resource, path, this.xpathProcessor);
                // replace?
                if (replacePath != null) {
                    try {
                        Node replaceNode = DOMUtil.getSingleNode(parent, replacePath, this.xpathProcessor);
                        // now get the parent of this node until it is the parent node for insertion
                        while (replaceNode != null && !replaceNode.getParentNode().equals(parent)) {
                           replaceNode = replaceNode.getParentNode();
                        }
                        if (replaceNode != null) {
                            if (overwrite) {
                                if (parent.getNodeType() == Node.DOCUMENT_NODE) {
                                    // replacing of the document element is not allowed
                                    resource = newDocument();
                                    resource.appendChild(resource.importNode(importNode, true));
                                    parent = resource;
                                    replaceNode = resource.importNode(replaceNode, true);
                                } else {
                                    parent.replaceChild(importNode, replaceNode);
                                }
                                message += ", replacing: " + replacePath;
                                if (reinsertPath != null) {
                                    Node insertAt = DOMUtil.getSingleNode(parent, reinsertPath, this.xpathProcessor);
                                    if (insertAt != null) {
                                        while (replaceNode.hasChildNodes()) {
                                            insertAt.appendChild(replaceNode.getFirstChild());
                                        }
                                    } else { // reinsert point null
                                        message = "replace failed, could not find your reinsert path: " + reinsertPath;
                                        resource = null;
                                    }
                                }
                            } else { // overwrite was false
                                message = "replace failed, no overwrite allowed.";
                                resource = null;
                            }
                        } else { // specified replaceNode was not found
                            parent.appendChild(importNode);
                        }
                    } catch (javax.xml.transform.TransformerException sax) {
                        throw new ProcessingException("TransformerException: " + sax, sax);
                    }
                } else { // no replace path, just do an insert at end
                    parent.appendChild(importNode);
                }
            // Create?
            } else if (create) {
                // Create new document
                resource = newDocument();
                // Import the fragment
                Node importNode = resource.importNode(fragment, true);
                if (path.length() == 0) {
                    // Parent node is document itself
                    NodeList nodes = importNode.getChildNodes();
                    for (int i = 0; i <  nodes.getLength();) {
                        Node node = nodes.item(i);
                        switch (node.getNodeType()) {
                            case Node.ELEMENT_NODE:
                                // May throw exception if fragment has more than one element
                                resource.appendChild(node);
                                break;
                            case Node.DOCUMENT_TYPE_NODE:
                            case Node.PROCESSING_INSTRUCTION_NODE:
                            case Node.COMMENT_NODE:
                                resource.appendChild(node);
                                break;
                            default:
                                // Ignore all other nodes
                                i++;
                                break;
                        }
                    }
                    message = "entire source overwritten";
                } else {
                    // Get the parent node
                    Node parent = DOMUtil.selectSingleNode(resource, path, this.xpathProcessor);
                    // Add a fragment
                    parent.appendChild(importNode);
                    message = "content appended to: " + path;
                }
            // Oops: Document does not exist and create is not allowed.
            } else {
                message = "create not allowed";
                resource = null;/**/
            }
            // Write source
            if (resource != null) {
                resource.normalize();
                // use serializer
                if (localSerializer == null) {
                    localSerializer = this.configuredSerializerName;
                }
                if (localSerializer != null) {
                    // Lookup the Serializer
                    ServiceSelector selector = null;
                    Serializer serializer = null;
                    OutputStream oStream = null;
                    try {
                        selector = (ServiceSelector)manager.lookup(Serializer.ROLE + "Selector");
                        serializer = (Serializer)selector.select(localSerializer);
                        oStream = ws.getOutputStream();
                        serializer.setOutputStream(oStream);
                        DOMStreamer streamer = new DOMStreamer(serializer);
                        streamer.stream(resource);
                    } finally {
                        if (oStream != null) {
                            oStream.flush();
                            try {
                                oStream.close();
                                failed = false;
                            } catch (Throwable t) {
                                if (getLogger().isDebugEnabled()) {
                                    getLogger().debug("FAIL (oStream.close) exception"+t, t);
                                }
                                throw new ProcessingException("Could not process your document.", t);
                            } finally {
                                if (selector != null) {
                                    selector.release(serializer);
                                    this.manager.release(selector);
                                }
                            }
                        }
                    }
                } else {
                    if (getLogger().isDebugEnabled()) {
                        getLogger().debug("ERROR: No serializer");
                    }
                    //throw new ProcessingException("No serializer specified for writing to source " + systemID);
                    message = "That source requires a serializer, please add the appropirate tag to your code.";
                }
            }
        } catch (DOMException de) {
            if (getLogger().isDebugEnabled()) {
                getLogger().debug("FAIL exception: "+de, de);
            }
            message = "There was a problem manipulating your document: " + de;
        } catch (ServiceException ce) {
            if (getLogger().isDebugEnabled()) {
                getLogger().debug("FAIL exception: "+ce, ce);
            }
            message = "There was a problem looking up a component: " + ce;
        } catch (SourceException se) {
            if (getLogger().isDebugEnabled()) {
                getLogger().debug("FAIL exception: "+se, se);
            }
            message = "There was a problem resolving that source: [" + systemID + "] : " + se;
        } finally {
            this.resolver.release(source);
        }
        // Report result
        String result = (failed) ? RESULT_FAILED : RESULT_SUCCESS;
        String action = ACTION_NONE;
        if (!failed) {
            action = (exists) ? ACTION_OVER : ACTION_NEW;
        }
        reportResult(localSerializer, tagname, message, target, result, action);
}

Insert a fragment into a file. The file is loaded by the resource connector.

 public  void service(ServiceManager manager) throws ServiceException 
{
        super.service(manager);
        this.xpathProcessor = (XPathProcessor) this.manager.lookup(XPathProcessor.ROLE);
}

 public  void setup(SourceResolver resolver,
    Map objectModel,
    String src,
    Parameters par) throws IOException, SAXException, ProcessingException 
{
        super.setup(resolver, objectModel, src, par);
        this.configuredSerializerName = par.getParameter(SERIALIZER_ATTRIBUTE,
                                                         this.configuredSerializerName);
        this.state = STATE_OUTSIDE;
}

Get the Parameter called "serializer" from the Transformer invocation.

 public  void startTransformingElement(String uri,
    String name,
    String raw,
    Attributes attr) throws IOException, SAXException, ProcessingException 
{
        if (getLogger().isDebugEnabled()) {
            getLogger().debug("Start transforming element. uri=" + uri +
                              ", name=" + name + ", raw=" + raw + ", attr=" + attr);
        }
        // Element: insert
        if (this.state == STATE_OUTSIDE
            && (name.equals(INSERT_ELEMENT) || name.equals(WRITE_ELEMENT))) {
            this.state = (name.equals(INSERT_ELEMENT) ? STATE_INSERT : STATE_WRITE);
            this.parent_state = this.state;
            if (attr.getValue(CREATE_ATTRIBUTE) != null
                && attr.getValue(CREATE_ATTRIBUTE).equals("false")) {
                this.stack.push("false");
            } else {
                this.stack.push("true"); // default value
            }
            if (attr.getValue(OVERWRITE_ATTRIBUTE) != null
                && attr.getValue(OVERWRITE_ATTRIBUTE).equals("false")) {
                this.stack.push("false");
            } else {
                this.stack.push("true"); // default value
            }
            this.stack.push(attr.getValue(SERIALIZER_ATTRIBUTE));
            this.stack.push("END");
        // Element: delete
        } else if (this.state == STATE_OUTSIDE && name.equals(DELETE_ELEMENT)) {
            this.state = STATE_DELETE;
            this.parent_state = state;
            this.stack.push("END");
        // Element: file
        } else if (name.equals(SOURCE_ELEMENT)
                   && (this.state == STATE_INSERT || this.state == STATE_WRITE || this.state == STATE_DELETE)) {
            this.state = STATE_FILE;
            this.startTextRecording();
        // Element: path
        } else if (name.equals(PATH_ELEMENT)
                   && (this.state == STATE_INSERT || this.state == STATE_WRITE || this.state == STATE_DELETE)) {
            this.state = STATE_PATH;
            this.startTextRecording();
        // Element: replace
        } else if (name.equals(REPLACE_ELEMENT)
                   && this.state == STATE_INSERT) {
            this.state = STATE_REPLACE;
            this.startTextRecording();
        // Element: fragment
        } else if (name.equals(FRAGMENT_ELEMENT)
                   &&  (this.state == STATE_INSERT || this.state == STATE_WRITE || this.state == STATE_DELETE)) {
            this.state = STATE_FRAGMENT;
            this.startRecording();
        // Element: reinsert
        } else if (name.equals(REINSERT_ELEMENT)
                   && this.state == STATE_INSERT) {
            this.state = STATE_REINSERT;
            this.startTextRecording();
        } else {
            super.startTransformingElement(uri, name, raw, attr);
        }
}

Receive notification of the beginning of an element.