TraceEventMulticaster.java

package client.net.sf.saxon.ce.trace;


import java.util.EventListener;

import client.net.sf.saxon.ce.Controller;
import client.net.sf.saxon.ce.expr.XPathContext;
import client.net.sf.saxon.ce.lib.TraceListener;
import client.net.sf.saxon.ce.om.Item;

/**
 * A class which implements efficient and thread-safe multi-cast event
 * dispatching for the TraceListener evants.
 */
public class TraceEventMulticaster implements TraceListener {

    protected final EventListener a, b;

    /**
     * Creates an event multicaster instance which chains listener-a
     * with listener-b.
     *
     * @param a listener-a
     * @param b listener-b
     */
    protected TraceEventMulticaster(EventListener a, EventListener b) {
        this.a = a;
        this.b = b;
    }

//    public void setOutputDestination(PrintStream stream) {
//        ((TraceListener)a).setOutputDestination(stream);
//        ((TraceListener)b).setOutputDestination(stream);
//    }

    /**
     * Removes a listener from this multicaster and returns the
     * resulting multicast listener.
     *
     * @param oldl the listener to be removed
     */
    /*@Nullable*/ protected EventListener remove(EventListener oldl) {
        if (oldl == a) {
            return b;
        }
        if (oldl == b) {
            return a;
        }
        EventListener a2 = removeInternal(a, oldl);
        EventListener b2 = removeInternal(b, oldl);
        if (a2 == a && b2 == b) {
            return this;    // it's not here
        }
        return addInternal(a2, b2);
    }

    /**
     * Called at start
     */

    public void open() {
        ((TraceListener)a).open();
        ((TraceListener)b).open();
    }

    /**
     * Called at end
     */

    public void close() {
        ((TraceListener)a).close();
        ((TraceListener)b).close();
    }


    /**
     * Called when an element of the stylesheet gets processed
     */
    public void enter(InstructionInfo element, XPathContext context) {
        ((TraceListener)a).enter(element, context);
        ((TraceListener)b).enter(element, context);
    }

    /**
     * Called after an element of the stylesheet got processed
     */
    public void leave(InstructionInfo element) {
        ((TraceListener)a).leave(element);
        ((TraceListener)b).leave(element);
    }

    /**
     * Called when an item becomes current
     */
    public void startCurrentItem(Item item) {
        ((TraceListener)a).startCurrentItem(item);
        ((TraceListener)b).startCurrentItem(item);
    }

    /**
     * Called when an item ceases to be the current item
     */
    public void endCurrentItem(Item item) {
        ((TraceListener)a).endCurrentItem(item);
        ((TraceListener)b).endCurrentItem(item);
    }

    /**
     * Adds trace-listener-a with trace-listener-b and
     * returns the resulting multicast listener.
     *
     * @param a trace-listener-a
     * @param b trace-listener-b
     */
    public static TraceListener add(TraceListener a, TraceListener b) {
        return (TraceListener)addInternal(a, b);
    }

    /**
     * Removes the old trace-listener from trace-listener-l and
     * returns the resulting multicast listener.
     *
     * @param l    trace-listener-l
     * @param oldl the trace-listener being removed
     */
    public static TraceListener remove(TraceListener l, TraceListener oldl) {
        return (TraceListener)removeInternal(l, oldl);
    }

    /**
     * Returns the resulting multicast listener from adding listener-a
     * and listener-b together.
     * If listener-a is null, it returns listener-b;
     * If listener-b is null, it returns listener-a
     * If neither are null, then it creates and returns
     * a new EventMulticaster instance which chains a with b.
     *
     * @param a event listener-a
     * @param b event listener-b
     */
    protected static EventListener addInternal(EventListener a, EventListener b) {
        if (a == null) {
            return b;
        }
        if (b == null) {
            return a;
        }
        return new TraceEventMulticaster(a, b);
    }

    /**
     * Returns the resulting multicast listener after removing the
     * old listener from listener-l.
     * If listener-l equals the old listener OR listener-l is null,
     * returns null.
     * Else if listener-l is an instance of SaxonEventMulticaster,
     * then it removes the old listener from it.
     * Else, returns listener l.
     *
     * @param l    the listener being removed from
     * @param oldl the listener being removed
     */

    protected static EventListener removeInternal(EventListener l, EventListener oldl) {
        if (l == oldl || l == null) {
            return null;
        } else if (l instanceof TraceEventMulticaster) {
            return ((TraceEventMulticaster)l).remove(oldl);
        } else {
            return l;        // it's not here
        }
    }

}

// Contributors: Edwin Glaser (edwin@pannenleiter.de); Michael Kay (Saxonica)

// This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. 
// If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
// This Source Code Form is “Incompatible With Secondary Licenses”, as defined by the Mozilla Public License, v. 2.0.