streameventmulticaster.java

java语言开发的P2P流媒体系统

/* 
 * P2P-Radio - Peer to peer streaming system
 * Project homepage: http://p2p-radio.sourceforge.net/
 * Copyright (C) 2003-2004 Michael Kaufmann <[e-mail]>
 * 
 * ---------------------------------------------------------------------------
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * ---------------------------------------------------------------------------
 */

/* This class is based on AWTEventMulticaster.java of GNU Classpath 0.10 */

package p2pradio.event;

public class StreamEventMulticaster implements
  HeaderChangedListener, MetadataChangedListener,
  DataLeapListener, WaitForLeadListener
{
	protected final StreamEventListener a;
	protected final StreamEventListener b;

	protected StreamEventMulticaster(StreamEventListener a, StreamEventListener b)
	{
		this.a = a;
		this.b = b;
	}

	protected StreamEventListener remove(StreamEventListener oldl)
	{
		if (a == oldl)
		{
			return b;
		}
		
		if (b == oldl)
		{
			return a;
		}

		if (a instanceof StreamEventMulticaster)
		{
			StreamEventListener newa = ((StreamEventMulticaster) a).remove(oldl);
			
			if (newa != a)
			{
				return new StreamEventMulticaster(newa, b);
			}
		}
		
		if (b instanceof StreamEventMulticaster)
		{
			StreamEventListener newb = ((StreamEventMulticaster) b).remove(oldl);
			
			if (newb != b)
			{
				return new StreamEventMulticaster(a, newb);
			}
		}

		return this;
	}

	public void headerChanged(HeaderChangedEvent e)
	{
		((HeaderChangedListener) a).headerChanged(e);
		((HeaderChangedListener) b).headerChanged(e);		
	}
	
	public void metadataChanged(MetadataChangedEvent e)
	{
		((MetadataChangedListener) a).metadataChanged(e);
		((MetadataChangedListener) b).metadataChanged(e);		
	}

	public void dataLeap(DataLeapEvent e)
	{
		((DataLeapListener) a).dataLeap(e);
		((DataLeapListener) b).dataLeap(e);		
	}
	
	public void waitForLead(WaitForLeadEvent e)
	{
		((WaitForLeadListener) a).waitForLead(e);
		((WaitForLeadListener) b).waitForLead(e);		
	}

	public static HeaderChangedListener add(HeaderChangedListener a, HeaderChangedListener b)
	{
		return (HeaderChangedListener) addInternal(a, b);
	}

	public static MetadataChangedListener add(MetadataChangedListener a, MetadataChangedListener b)
	{
		return (MetadataChangedListener) addInternal(a, b);
	}
	
	public static DataLeapListener add(DataLeapListener a, DataLeapListener b)
	{
		return (DataLeapListener) addInternal(a, b);
	}

	public static WaitForLeadListener add(WaitForLeadListener a, WaitForLeadListener b)
	{
		return (WaitForLeadListener) addInternal(a, b);
	}

	public static HeaderChangedListener remove(HeaderChangedListener l, HeaderChangedListener oldl)
	{
		return (HeaderChangedListener) removeInternal(l, oldl);
	}
	
	public static MetadataChangedListener remove(MetadataChangedListener l, MetadataChangedListener oldl)
	{
		return (MetadataChangedListener) removeInternal(l, oldl);
	}
	
	public static DataLeapListener remove(DataLeapListener l, DataLeapListener oldl)
	{
		return (DataLeapListener) removeInternal(l, oldl);
	}
	
	public static WaitForLeadListener remove(WaitForLeadListener l, WaitForLeadListener oldl)
	{
		return (WaitForLeadListener) removeInternal(l, oldl);
	}
	
	protected static StreamEventListener addInternal(StreamEventListener a, StreamEventListener b)
	{
		if (a == null)
		{
			return b;
		}
		
		if (b == null)
		{
			return a;
		}
		
		return new StreamEventMulticaster(a, b);
	}

	protected static StreamEventListener removeInternal(StreamEventListener l, StreamEventListener oldl)
	{
		if (l == oldl)
		{
			return null;
		}
		
		if (l instanceof StreamEventMulticaster)
		{
			return ((StreamEventMulticaster) l).remove(oldl);
		}
		
		return l;
	}
}