com.qspin.qtaste.tools.converter.model.EventManager Maven / Gradle / Ivy

Go to download
package com.qspin.qtaste.tools.converter.model;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.log4j.Logger;

import com.qspin.qtaste.tools.converter.model.event.Event;
import com.qspin.qtaste.tools.filter.Filter;

/**
 * Responsible for the management/filtering  of the events.
 * Implemented with the singleton pattern.
 * @author simjan
 *
 */
public class EventManager {

	/**
	 * Returns the unique instance of the manager. If non exist, creates one.
	 * @return the unique instance of the manager.
	 */
	public synchronized static EventManager getInstance()
	{
		if ( INSTANCE == null ) {
			INSTANCE = new EventManager();
		}
		return INSTANCE;
	}
	
	/**
	 * Loads and filters the events into the manager.
	 * @param pEvents
	 */
	public void setEvents(List pEvents)
	{
		if(  pEvents == null ) {
			pEvents = new ArrayList();
		}
		List old = mEvents;
		mEvents.clear();
		mUnfilteredEvents = pEvents;
		mComponentNameMap.clear();
		mEventTypeMap.clear();
		mEventAliasMap.clear();
		
		for ( Event evt : pEvents )
		{
			if ( mFilters != null )
			{
				boolean canbeUsed = true;
				for ( Filter f : mFilters )
				{
					if ( !f.accept(evt) )
					{
						canbeUsed = false;
						break;
					}
				}
				if ( !canbeUsed )
				{
					continue;
				}
			}
			if ( !mComponentNameMap.containsKey(evt.getComponentName()) )
			{
				mComponentNameMap.put(evt.getComponentName(), new ArrayList());
			}
			if ( !mEventTypeMap.containsKey(evt.getType() )) {
				mEventTypeMap.put(evt.getType(), new ArrayList());
			}
			mComponentNameMap.get(evt.getComponentName()).add(evt);
			mEventTypeMap.get(evt.getType()).add(evt);
			mEvents.add(evt);
		}
		
		firePropertyChange(new PropertyChangeEvent(this, DATA_CHANGE_PROPERTY_ID, old, pEvents));
	}
	
	/**
	 * Returns all events registered for the component identified by the name.
	 * @param pComponentName
	 * @return all events registered for the component identified by the name.
	 */
	public List getEventsForComponent(String pComponentName)
	{
		if ( mComponentNameMap.containsKey(pComponentName) )
		{
			return mComponentNameMap.get(pComponentName);
		}
		return new ArrayList();
	}
	
	/**
	 * Registers the listener to receive an event when events, filters or alias change.
	 * @param pListener
	 */
	public void addPropertyChangeListener( PropertyChangeListener pListener)
	{
		mListener.add(pListener);
	}
	
	public void removePropertyChangeListener( PropertyChangeListener pListener)
	{
		mListener.remove(pListener);
	}
	
	public List getFilteredEvents()
	{
		return mEvents;
	}

	public boolean isNameFree(String text) {
		return !mComponentNameMap.containsKey(text);
	}
	
	public Object[] getComponentNames()
	{
		Object[] array = mComponentNameMap.keySet().toArray();;
		Arrays.sort(array);
		return array;
	}
	
	public Object[] getEventTypes()
	{
		Object[] array = mEventTypeMap.keySet().toArray();;
		Arrays.sort(array);
		return array;
	}

	public void setComponentAlias(String pComponentName, String pAlias) {
		List events = new ArrayList(mUnfilteredEvents);
		for ( Event e : events )
		{
			if(  e.getComponentName().equals(pComponentName) ) {
				e.setAlias(pAlias);
			}
		}
		try {
			ComponentNameMapping.getInstance().setAliasFor(pComponentName, pAlias);
		} catch (IOException pExc)
		{
			LOGGER.warn(pExc);
		}
		setEvents(events);
	}
	
	public void setEventsFilter(List pFilter) {
		List old = mFilters;
		mFilters = pFilter;
		
		setEvents(mUnfilteredEvents);
		firePropertyChange(new PropertyChangeEvent(this, FILTER_CHANGE_PROPERTY_ID, old, pFilter));
	}
	
	protected void firePropertyChange(PropertyChangeEvent pEvt)
	{
		for ( PropertyChangeListener listener : mListener )
		{
			listener.propertyChange(pEvt);
		}
	}
	
	protected EventManager() {
		mComponentNameMap = new HashMap>();
		mEventTypeMap = new HashMap>();
		mListener = new ArrayList();
		mEventAliasMap = new HashMap();
		mEvents = new ArrayList();
		setEvents(null);
	}

	private List mEvents;
	private List mUnfilteredEvents;
	private Map> mComponentNameMap;
	private Map> mEventTypeMap;
	private Map mEventAliasMap;
	private List mFilters;
	private List mListener;
	
	protected static EventManager INSTANCE;
	protected static final Logger LOGGER = Logger.getLogger(EventManager.class);

	public static final String DATA_CHANGE_PROPERTY_ID = "dataUpdate";
	public static final String ALIAS_CHANGE_PROPERTY_ID = "aliasUpdate";
	public static final String FILTER_CHANGE_PROPERTY_ID = "filterUpdate";
}