/*******************************************************************************
* Copyright (c) 2009, 2014 SAP AG and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* SAP AG - initial API and implementation
******************************************************************************/
package org.eclipse.ocl.examples.eventmanager.framework;
import java.lang.ref.Reference;
import java.lang.ref.WeakReference;
import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.WeakHashMap;
import java.util.logging.Logger;
import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.ocl.examples.eventmanager.EventFilter;
import org.eclipse.ocl.examples.eventmanager.EventManagerFactory;
import org.eclipse.ocl.examples.eventmanager.filters.AbstractEventFilter;
import org.eclipse.ocl.examples.eventmanager.filters.AndFilter;
import org.eclipse.ocl.examples.eventmanager.filters.LogicalOperationFilter;
import org.eclipse.ocl.examples.eventmanager.filters.NotFilter;
import org.eclipse.ocl.examples.eventmanager.filters.OrFilter;
import org.eclipse.ocl.examples.eventmanager.util.Bag;
import org.eclipse.ocl.examples.eventmanager.util.Statistics;
/**
* The <code>RegistrationManager</code> is responsible for storing the listeners and their registrations and for computing the set
* of affected listeners for a certain event. <br>
* The <code>RegistrationManager</code> has knowledge about several things: <br>
* <ul>
* <li>it knows the event types that have to be forwarded to certain <code>EventFilterTables</code></li>
* <li>It knows the filter type that belongs to a table.</li>
* <li>It knows the registrations that belong to a listener.</li>
* </ul>
* <br>
* The first two points are defined in the {@link #init()} method which is implemented in the subclass
* {@link RegistrationManagerTableBased} because originally there also were other
* subtypes of <code>RegistrationManager</code> (e.g. the GlobalRegistrationManager). <br>
* This knowledge enables the <code>RegistrationManager</code> to fill the <code>EventFilterTables</code> with new registrations
* and to compute all listeners that are registered to a certain event. The knowledge of the registrations that belong to a
* listener is primary for performance improvement at deregistration time. The
* {@link org.eclipse.ocl.examples.eventmanager.framework.TableForEventFilter} provide registrations for an event in
* one context. When an event is being fired, the <code>RegistrationManager</code> will know which <code>EventFilterTables</code>
* to ask and can collect all registrations from all affected <code>EventFilterTables</code>. The <code>RegistrationManager</code>
* has the overview and can merge these candidates into a consolidated set of registrations. Afterwards these Registrations are
* converted into listeners that will have to be notified.
*
* @author Daniel Vocke (D044825), Axel Uhl (D043530)
*/
public class RegistrationManagerTableBased {
private Logger logger = Logger.getLogger(RegistrationManagerTableBased.class.getName());
// uncomment the following lines in case you want to record statistics about the minimum table size;
// but pay attention: this method runs in the innermost loop of the event manager, and even a method
// call to an empty method may consume some time
// /**
// * group ID for {@link Statistics} capturing the minimum table sizes during event handling
// */
// public static final String GROUP_ID_MINIMUM_TABLE_SIZE = "minimumTableSize*1000000";
// needed to compute the affected registrations for an event
private final HashMap<Integer, Set<TableForEventFilter>> tablesByEventType = new HashMap<Integer, Set<TableForEventFilter>>();
/*
* needed for registering purposes. The key may consist of either java.lang.Class or a list containing the class and
* additional identifying information
*/
private final HashMap<Object, TableForEventFilter> tableByFilterType = new HashMap<Object, TableForEventFilter>();
/**
* During {@link #register(AbstractEventFilter, WeakReference, ListenerTypeEnum) registration}, weak references
* to adapters are passed in. To enable {@link #deregister(Adapter) deregistration} by direct references
* to the adapter, this field keeps the mapping between the adapters and their weak references. It does
* so in a {@link WeakHashMap} such that again no strong references to the adapter are introduced by
* the event manager framework.
*/
private final WeakHashMap<Adapter, Set<Reference<? extends Adapter>>> adaptersToWeakRefs = new WeakHashMap<Adapter, Set<Reference<? extends Adapter>>>();
/**
* maps the weak references to the adapters passed to
* {@link #register(AbstractEventFilter, WeakReference, ListenerTypeEnum)} to the
* registration sets constructed for their event filter; when implicit
* de-registration occurs due to the adapter getting garbage collected, this
* structure is used to clean up the registrations.
*/
private final Map<Reference<? extends Adapter>, List<RegistrationSet>> registrationSetByListenerReference = new HashMap<Reference<? extends Adapter>, List<RegistrationSet>>();
/**
* Maintains the registrations keyed by their {@link AndFilter}. It is used to find existing registrations
* matching an {@link AndFilter} occurring in a filter tree for which a new {@link RegistrationSet} is to
* be assembled and added to the event manager's tables. This enables efficient re-use of registrations.
*/
private Map<AndFilter, Registration> allRegistrations = new HashMap<AndFilter, Registration>();
/**
* The elements 0..{@link #numberOfBitSetsWithAtLeastOneRegistration-1} store those bit set values for which
* {@link #allRegistrations} has at least one registration with that {@link Registration#getBitSetForTablesRegisteredWith()
* bit set}. The array may need to be reorganized when registrations come and go. Registrations for so far unused
* bit sets are added at index {@link #numberOfBitSetsWithAtLeastOneRegistration} and the attribute
* {@link #numberOfBitSetsWithAtLeastOneRegistration} is incremented by one. When deregistering, the array is
* reconstructed from {@link #allRegistrations}.
*/
private int[] bitSetsWithAtLeastOneRegistration;
private int numberOfBitSetsWithAtLeastOneRegistration;
/**
* Invariants:
* <p>
* <code>filterTypeToBitMask.get(allTables[i].getIdentifier()) = 2<<i</code>
* <p>
* <code>filterTypeToBitMask.keySet().equals(allTables.getIdentifier())</code>
*
* In other words: the identifying classes of all tables stored in this list occur as keys in {@link #filterTypeToBitMask},
* and the order in which the tables occur in this list matches with the bit number of the bit mask returned by
* {@link #filterTypeToBitMask} as value for the key being the respective table's {@link TableForEventFilter#getIdentifier()
* identifier}
*/
private TableForEventFilter[] allTables;
// The EventTypeFilterTable will also be used with custom events
protected TableForEventFilter eventTypeFilterTable = null;
// a table with negated registrations always has a contribution to an event
// (except the negated registration covers exactly the current event)
protected Set<TableForEventFilter> tablesWithNegatedRegistrations = new HashSet<TableForEventFilter>();
/**
* Maps the class of a filter to the bit mask it has in finding the correct array position
* in an array of registration sets
*/
private Map<Class<? extends EventFilter>, Integer> filterTypeToBitMask;
/**
* Maps the filter tables from {@link #allTables} to the integer positions they have in {@link #allTables}
* for fast look-up.
*/
private final Map<TableForEventFilter, Integer> tableToIndexInAllTables = new HashMap<TableForEventFilter, Integer>();
public RegistrationManagerTableBased() {
init();
}
/**
* The implementation of the <code>init()</code> method initialises the members above.
* Performs the "configuration" of the RegistrationManager.
*/
protected void init() {
filterTypeToBitMask = new HashMap<Class<? extends EventFilter>, Integer>();
@SuppressWarnings("unchecked")
Class<? extends TableForEventFilter>[] tableTypes = (Class<? extends TableForEventFilter>[]) new Class<?>[] {
TableForStructuralFeatureFilter.class, TableForClassFilter.class,
TableForClassFilterIncludingSubClasses.class,
TableForEventTypeFilter.class, TableForContainmentFilter.class,
TableForNewValueClassFilter.class, TableForOldValueClassFilter.class,
TableForNewValueClassFilterIncludingSubclasses.class, TableForOldValueClassFilterIncludingSubclasses.class};
createAllTables(tableTypes.length);
int i=0;
for (Class<? extends TableForEventFilter> tableType : tableTypes) {
TableForEventFilter table;
try {
Constructor<? extends TableForEventFilter> constructor = tableType.getConstructor(Integer.TYPE);
table = constructor.newInstance(tableTypes.length);
} catch (Exception e) {
throw new RuntimeException("Didn't find constructor(int) on table type "+tableType.getSimpleName(), e);
}
setUsualEvents(table);
registerTable(table, i++);
}
}
protected void createAllTables(int size) {
allTables = new TableForEventFilter[size];
bitSetsWithAtLeastOneRegistration = new int[1<<size];
numberOfBitSetsWithAtLeastOneRegistration = 0;
}
private void setUsualEvents(TableForEventFilter table) {
addTableForEventType(table, Notification.SET);
addTableForEventType(table, Notification.UNSET);
addTableForEventType(table, Notification.ADD);
addTableForEventType(table, Notification.REMOVE);
addTableForEventType(table, Notification.ADD_MANY);
addTableForEventType(table, Notification.REMOVE_MANY);
addTableForEventType(table, Notification.MOVE);
}
/**
* registers a listener with the passed filter expression. The returned object of type <code>RegistrationHandle</code> is
* intended to be used as handle for deregistration puposes.
*
* @param filterTree
* the filter expression (may also be a tree)
* @param listener
* the listener to register
*/
public synchronized void register(EventFilter filterTree, WeakReference<? extends Adapter> listener,
ListenerTypeEnum listenerType) {
// adjustFilter() has to be called before the dnf is formed, but there has to be at least one logicaloperationfilter at
// the top
if (!(filterTree instanceof OrFilter || filterTree instanceof AndFilter)) {
EventFilter topOfTree = EventManagerFactory.eINSTANCE.createAndFilterFor(filterTree);
filterTree = topOfTree;
}
OrFilter filterInNormalForm = getDisjunctiveNormalForm((LogicalOperationFilterImpl) filterTree);
// visit the whole filter tree and add each atomic filter to its corresponding filterTable.
List<Registration> registrations = new LinkedList<Registration>();
for (EventFilter filter : filterInNormalForm.getOperands()) {
AndFilter andFilter = (AndFilter) filter;
Registration reg = allRegistrations.get(andFilter);
if (reg == null) {
reg = createRegistration(andFilter);
}
registrations.add(reg);
}
RegistrationSet result = new RegistrationSet(listener, listenerType, registrations);
addRegistrationForListener(result, listener);
}
/**
* Creates the registration and adds it to {@link #allRegistrations}
*/
private Registration createRegistration(AndFilter andFilter) {
int[] requiredMatchesPerTable = new int[allTables.length];
Map<EventFilter, TableForEventFilter> filterTablesToRegisterWith = getFilterTablesToRegisterWith(
andFilter, requiredMatchesPerTable);
Registration result = new Registration(
getBitSet(filterTablesToRegisterWith.values()), andFilter,
requiredMatchesPerTable);
allRegistrations.put(andFilter, result);
updateBitSetsWithAtLeastOneRegistration(result);
for (Entry<EventFilter, TableForEventFilter> filterTableEntry : filterTablesToRegisterWith
.entrySet()) {
filterTableEntry.getValue().register(filterTableEntry.getKey(),
result);
}
return result;
}
/**
* Ensures that {@link #bitSetsWithAtLeastOneRegistration} contains <code>registration</code>.
* {@link Registration#getBitSetForTablesRegisteredWith()} in elements 0..{@link #numberOfBitSetsWithAtLeastOneRegistration}
* -1. It may have to append the bit set value to the end. In this case, {@link #numberOfBitSetsWithAtLeastOneRegistration}
* will be incremented by one.
*/
private void updateBitSetsWithAtLeastOneRegistration(Registration registration) {
int bitset = registration.getBitSetForTablesRegisteredWith();
for (int i=0; i<numberOfBitSetsWithAtLeastOneRegistration; i++) {
if (bitSetsWithAtLeastOneRegistration[i] == bitset) {
return;
}
}
bitSetsWithAtLeastOneRegistration[numberOfBitSetsWithAtLeastOneRegistration++] = bitset;
}
/**
* @param requiredMatchesPerTable
* Expected to contain only 0 values upon invocation. Updated by
* this method with the number of matches that the
* {@link Registration} to be created from the results of this
* method expects to find in the respective table. Indices in
* this array correspond to the indices in {@link #allTables}.
* When this method completes normally, this array will contain 0
* for all tables (see also {@link #tableToIndexInAllTables})
* that don't occur in the results {@link Map#values() values}
* and at least 1 for all tables that do occur.
*/
private Map<EventFilter, TableForEventFilter> getFilterTablesToRegisterWith(
AndFilter andFilter, int[] requiredMatchesPerTable) {
// determine tables to register with; needed already for construction of
// Registration
Map<EventFilter, TableForEventFilter> filterTablesToRegisterWith = new HashMap<EventFilter, TableForEventFilter>();
// The following table is used only for the possibility of error reporting
LogicalOperationFilterImpl level1OfTree = andFilter;
for (EventFilter leafOfTree : level1OfTree.getOperands()) {
TableForEventFilter filterTable = getFilterTable(leafOfTree);
if (filterTable == null) {
throw new IllegalArgumentException("no table for type " + leafOfTree.getClass()
+ " in RegistryManager defined");
}
requiredMatchesPerTable[tableToIndexInAllTables.get(filterTable)]++;
filterTablesToRegisterWith.put(leafOfTree, filterTable);
}
return filterTablesToRegisterWith;
}
private void addRegistrationForListener(RegistrationSet registrationSet, Reference<? extends Adapter> listenerRef) {
// registrationsByListener is a WeakHashMap, so direct references to listeners can be stored
Adapter adapter = listenerRef.get();
if (adapter == null) {
logger.warning("Registered adapter got GCed: "+listenerRef);
} else {
Set<Reference<? extends Adapter>> listenerSet = adaptersToWeakRefs.get(adapter);
if (listenerSet == null) {
listenerSet = new HashSet<Reference<? extends Adapter>>();
adaptersToWeakRefs.put(adapter, listenerSet);
}
listenerSet.add(listenerRef);
List<RegistrationSet> registrationSetList = registrationSetByListenerReference.get(listenerRef);
if (registrationSetList == null) {
registrationSetList = new ArrayList<RegistrationSet>();
registrationSetByListenerReference.put(listenerRef, registrationSetList);
}
registrationSetList.add(registrationSet);
}
}
/**
* From a collection of filter tables, computes the bit set representing this table combination.
*
* @see RegistrationManagerTableBased#filterTypeToBitMask
*/
private int getBitSet(Collection<TableForEventFilter> tables) {
int result = 0;
for (TableForEventFilter table : tables) {
result |= filterTypeToBitMask.get(table.getIdentifier());
}
return result;
}
private void deregister(RegistrationSet rs) {
for (Registration reg : ((RegistrationSet) rs).getRegistrations()) {
if (reg.removeRegistrationSet(rs)) {
// the registration lost its last registration set; remove from all tables
deregister(reg);
}
}
}
/**
* Removes all registrations that belong to the passed listener from all <code>EventFilterTables</code>. The listener will not
* receive any events any more. This method is synchronized because there must be no changes to the FilterTables while they
* are working.
*
* @param listener
* the listener to deregister
*/
public synchronized void deregister(Adapter listener) {
Set<Reference<? extends Adapter>> set = adaptersToWeakRefs.get(listener);
if (set != null) {
for (Reference<? extends Adapter> listenerRef : set) {
deregister(listenerRef);
}
}
}
public synchronized void deregister(Reference<? extends Adapter> listenerRef) {
Adapter adapter = listenerRef.get();
if (adapter != null) {
// not yet collected
adaptersToWeakRefs.remove(adapter);
}
List<RegistrationSet> registrationSets = registrationSetByListenerReference.get(listenerRef);
if (registrationSets != null) {
for (RegistrationSet registrationSet : registrationSets) {
deregister(registrationSet);
}
registrationSetByListenerReference.remove(listenerRef);
}
}
/**
* This method returns a {@link java.util.Collection} of {@link Adapter}s that were registered for the passed event.
*
* @param event
* @return a Collection of listeners that are registered for the passed event
*/
public Collection<WeakReference<? extends Adapter>> getListenersFor(Notification event) {
// this method does the main work, it computes the registrations from all EventFilterTables
Collection<Registration> registrations = getRegistrationsFor(event);
Collection<WeakReference<? extends Adapter>> result = new LinkedList<WeakReference<? extends Adapter>>();
// this collection is needed in order to remove duplicates. (it is possible, that two OR connected filter criteria matched.
// In this case, two different registrations will be returned (which both point to the same RegistrationSet), but
// the listener will expect to get notified only once.
Set<RegistrationSet> registrationSetsAddedSoFar = new HashSet<RegistrationSet>();
for (Registration reg : registrations) {
for (RegistrationSet registrationSet : reg.getRegistrationSets()) {
if (!registrationSetsAddedSoFar.contains(registrationSet)) {
registrationSetsAddedSoFar.add(registrationSet);
result.add(registrationSet.getListener());
}
}
}
return result;
}
/**
* Finds matching {@link Registration}s for <code>event</code>.
*/
private Set<Registration> getRegistrationsFor(Notification event) {
Statistics.getInstance().begin("getRegistrationsFor", event);
// insert is O(1) for linked list; no cloning / copying required as it grows
Set<Registration> result = new HashSet<Registration>();
// for the following two lists, the index corresponds to the table index in allTables
@SuppressWarnings("unchecked")
Bag<Registration>[][] yesSetsForTables = (Bag<Registration>[][]) new Bag<?>[allTables.length][];
@SuppressWarnings("unchecked")
Bag<Registration>[][] noSetsForTables = (Bag<Registration>[][]) new Bag<?>[allTables.length][];
int i=0;
for (TableForEventFilter table : allTables) {
Bag<Registration>[] yesSetsForTable = table.getYesSetsFor(event, numberOfBitSetsWithAtLeastOneRegistration, bitSetsWithAtLeastOneRegistration);
yesSetsForTables[i] = yesSetsForTable;
Bag<Registration>[] noSetsForTable = table.getNoSetsFor(event, numberOfBitSetsWithAtLeastOneRegistration, bitSetsWithAtLeastOneRegistration);
noSetsForTables[i] = noSetsForTable;
i++;
}
// loop over all table combinations (as bit set counter) for which registrations exist
HashSet<Registration> startSetToReuseToAvoidHashSetCreation = new HashSet<Registration>();
for (int bitSetIndex=0; bitSetIndex<numberOfBitSetsWithAtLeastOneRegistration; bitSetIndex++) {
addIntersectionOverTablesInBitset_Of_YesSetUnitedWithAllNoSetMinusNoSet(bitSetsWithAtLeastOneRegistration[bitSetIndex],
yesSetsForTables, noSetsForTables, result, startSetToReuseToAvoidHashSetCreation);
}
Statistics.getInstance().end("getRegistrationsFor", event);
return result;
}
private void addIntersectionOverTablesInBitset_Of_YesSetUnitedWithAllNoSetMinusNoSet(
int bitSetForTableCombination,
Bag<Registration>[][] yesSetsForTables,
Bag<Registration>[][] noSetsForTables, Set<Registration> result,
HashSet<Registration> startSetToReuseToAvoidHashSetCreation) {
// first, determine maximum size of (yesSet "union" allNo \ no) for each
// table in the bit set;
// if the maximum size of one of them is 0, we're done; otherwise, start with the table promising the
// smallest size
int tableWithMinSize = getTableWithMinSizeForIntersection(bitSetForTableCombination, yesSetsForTables);
// construct the set to start with:
Collection<Registration> resultForTablesInBitSet = getStartCollectionFromMinSizeTable(bitSetForTableCombination,
yesSetsForTables, noSetsForTables, tableWithMinSize, startSetToReuseToAvoidHashSetCreation);
if (!resultForTablesInBitSet.isEmpty()) {
// now retain only those that are also in the (yesSet "union" allNo \ no) for all other tables in the bit set
for (int i = allTables.length - 1; i >= 0; i--) {
if (i != tableWithMinSize // don't intersect with start set again; wouldn't hurt except for performance
&& (bitSetForTableCombination & (1 << i)) != 0) { // loop over tables in bit set only
Iterator<Registration> resultIter = resultForTablesInBitSet.iterator();
while (resultIter.hasNext()) {
Registration next = resultIter.next();
if (!is_InYesOrCompleteNo_And_NotInNo_OfTable(next, i, bitSetForTableCombination, yesSetsForTables,
noSetsForTables)) {
resultIter.remove();
}
}
}
}
}
result.addAll(resultForTablesInBitSet);
}
private Collection<Registration> getStartCollectionFromMinSizeTable(
int bitSetForTableCombination,
Bag<Registration>[][] yesSetsForTables,
Bag<Registration>[][] noSetsForTables, int tableWithMinSize,
HashSet<Registration> resultForTablesInBitSet) {
resultForTablesInBitSet.clear();
Bag<Registration> yesSetForMinSizeTable = yesSetsForTables[tableWithMinSize][bitSetForTableCombination];
Bag<Registration> allNoForMinSizeTable = allTables[tableWithMinSize].getCompleteNoBag()[bitSetForTableCombination];
Bag<Registration> noSetForMinSizeTable = noSetsForTables[tableWithMinSize][bitSetForTableCombination];
// add those registrations that got exactly as many matches in the table as they require
if (yesSetForMinSizeTable != null) {
for (Registration r : yesSetForMinSizeTable) {
if ((noSetForMinSizeTable == null || !noSetForMinSizeTable.contains(r))
&& r.getMatchesRequiredForTable(tableWithMinSize) ==
yesSetForMinSizeTable.count(r) + (allNoForMinSizeTable == null ? 0 : allNoForMinSizeTable.count(r))) {
resultForTablesInBitSet.add(r);
}
}
}
if (allNoForMinSizeTable != null) {
for (Registration r : allNoForMinSizeTable) {
if ((noSetForMinSizeTable == null || !noSetForMinSizeTable.contains(r))
&& r.getMatchesRequiredForTable(tableWithMinSize) == (yesSetForMinSizeTable == null ? 0
: yesSetForMinSizeTable.count(r))
+ allNoForMinSizeTable.count(r)) {
resultForTablesInBitSet.add(r);
}
}
}
return resultForTablesInBitSet;
}
private int getTableWithMinSizeForIntersection(int bitSetForTableCombination, Bag<Registration>[][] yesSetsForTables) {
int[] maxSizes = new int[allTables.length]; // only those elements from the bit set will be populated
int minSize = Integer.MAX_VALUE; // minimum value that got explicitly set in sizes[]
int tableWithMinSize = -1; // position of minimum value in sizes[]; that's the table to start with for intersection
int tableBit = 1<<(allTables.length-1);
for (int i=allTables.length-1; i>=0; i--) {
if ((bitSetForTableCombination & tableBit) != 0) {
// table identified by tableBit occurs in the combination represented by bitSetForTableCombination
Bag<Registration> yesSet = yesSetsForTables[i][bitSetForTableCombination];
Bag<Registration> allNo = allTables[i].getCompleteNoBag()[bitSetForTableCombination];
maxSizes[i] = (yesSet == null ? 0 : yesSet.size()) + (allNo == null ? 0 : allNo.size());
if (maxSizes[i] < minSize) {
// will be executed at least once because we start with minSize=Integer.MAX_VALUE and
// there has to be at least one non-zero bit in the bit set
minSize = maxSizes[i];
tableWithMinSize = i;
}
}
tableBit >>= 1;
}
// uncomment the following line in case you want to record statistics about the minimum table size;
// but pay attention: this method runs in the innermost loop of the event manager, and even a method
// call to an empty method may consume some time
// Statistics.getInstance().record(GROUP_ID_MINIMUM_TABLE_SIZE, bitSetForTableCombination, 1000000*minSize);
return tableWithMinSize;
}
private boolean is_InYesOrCompleteNo_And_NotInNo_OfTable(
Registration registration, int table,
int bitSetForTableCombination,
Bag<Registration>[][] yesSetsForTable,
Bag<Registration>[][] noSetsForTables) {
Bag<Registration> yesSet = yesSetsForTable[table][bitSetForTableCombination];
Bag<Registration> allNo = allTables[table].getCompleteNoBag()[bitSetForTableCombination];
Bag<Registration> noSet = noSetsForTables[table][bitSetForTableCombination];
// add those registrations that got exactly as many matches in the table as they require
return
((yesSet != null) &&
((noSet == null || !noSet.contains(registration)) &&
registration.getMatchesRequiredForTable(table) ==
yesSet.count(registration) + (allNo == null ? 0 : allNo.count(registration))))
||
((allNo != null) &&
((noSet == null || !noSet.contains(registration)) &&
registration.getMatchesRequiredForTable(table) ==
(yesSet == null ? 0 : yesSet.count(registration)) + allNo.count(registration)));
}
/**
* @param listener
* @return whether the listener is registered
*/
public boolean isListenerRegistered(Adapter listener) {
return adaptersToWeakRefs.containsKey(listener);
}
/**
* Removes the passed registration from all affected FilterTables.
*
* @param registration
* the registration to remove
*/
private void deregister(Registration registration) {
for (TableForEventFilter table : allTables) {
table.deregister(registration);
if (table.isEmpty()) {
tablesWithNegatedRegistrations.remove(table);
}
}
allRegistrations.remove(registration.getAndFilter());
rebuildBitSetsWithAtLeastOneRegistration();
}
private void rebuildBitSetsWithAtLeastOneRegistration() {
Set<Integer> bitSetsInUse = new HashSet<Integer>();
for (Registration r : allRegistrations.values()) {
bitSetsInUse.add(r.getBitSetForTablesRegisteredWith());
}
numberOfBitSetsWithAtLeastOneRegistration = bitSetsInUse.size();
int i=0;
for (int bitSetInUse : bitSetsInUse) {
bitSetsWithAtLeastOneRegistration[i++] = bitSetInUse;
}
}
/**
* this is a private helper method. unfortunately there is no 1 to 1 mapping of event filter instances and EventFilterTable
* instances because some of the filters have modifiers like <code>
* includeSubclasses</code>. In this case, there is a seperate EventFilterTable instance for each value of the modifier. this
* method encapsulates this knowledge and always returns the right <code>FilterTable</code>
*
* @param filter
* the filter instance to find the correnponding FilterTable for
* @return the FilterTable which is reponsible for the passed filter instance
*/
private TableForEventFilter getFilterTable(EventFilter filter) {
return tableByFilterType.get(filter.getClass());
}
/**
* This method fills the <code>tablesByEventType</code> member with the passed parameters. It is only used in the
* <code>init()</code> method of subclasses.
*
* @param table
* @param eventType
*/
protected void addTableForEventType(TableForEventFilter table, Integer eventType) {
Set<TableForEventFilter> tables = tablesByEventType.get(eventType);
if (tables == null) {
tables = new HashSet<TableForEventFilter>();
tablesByEventType.put(eventType, tables);
}
tables.add(table);
}
/**
* Transforms the (sub-)tree into disjunctive normal form. This special form is needed internally for the following
* processing. The tree is not cloned before processing, so the clients that plan to reuse their FilterTrees will have to
* clone them using {@link #clone()} before registering to the EventFramework or invoking this method.
*
* @return a filter tree in disjunctive normal form which has exactly the same semantics like the original tree
*/
public static OrFilter getDisjunctiveNormalForm(LogicalOperationFilterImpl filter) {
// perhaps the tree is in DNF yet?
if (isInDisjunctiveNormalForm(filter))
return (OrFilter) filter;
LogicalOperationFilterImpl result = filter;
// eliminate negations and then expand the tree until the disjunctive
// normalform is reached
result = (LogicalOperationFilterImpl) eliminateNegations(result);
result = (LogicalOperationFilterImpl) getExpandedSubTree(null, result);
// expandSubTree might also produce a conjunctive normal form =>
// transform again
if (!isInDisjunctiveNormalForm(result))
result = (LogicalOperationFilterImpl) getExpandedSubTree(null, result);
else
return (OrFilter) result;
if (getDepth(result) < 2) {
// bring simple filters to disjunctive normalform
if (result instanceof OrFilter) {
/*
* This is currently an OrFilter which connects the leaves of the tree => between the OrFilter and each leaf, an
* AndFilter is inserted.
*/
LogicalOperationFilterImpl orfilter = new OrFilter();
for (EventFilter operand : result.getOperands()) {
LogicalOperationFilterImpl tmp = new AndFilter(operand);
orfilter.addOperand(tmp);
}
result = orfilter;
} else if (result instanceof AndFilter) {
/*
* This is an AndFilter which connects the leafs => put an OrFilter on the top of the tree
*/
LogicalOperationFilterImpl tmp = new OrFilter(result);
result = tmp;
} else if (result instanceof NotFilter) {
throw new IllegalStateException("Elimination of NotFilters failed");
}
}
if (!isInDisjunctiveNormalForm(result)) {
if(result instanceof OrFilter){
/*
* there might be primitives left as direct children --> encapsulate them into AndFilters
* a | b | (c & d) -- > (a &) | (b &) | (c & d)
*/
Set<EventFilter> oldO = result.getOperands();
LogicalOperationFilterImpl orfilter = new OrFilter();
for(EventFilter f: oldO){
if(!(f instanceof LogicalOperationFilter)){
orfilter.addOperand(EventManagerFactory.eINSTANCE.createAndFilterFor(f));
}else{
orfilter.addOperand(f);
}
}
result = orfilter;
if (!isInDisjunctiveNormalForm(result)) {
throw new IllegalStateException("Could not create disjunctiv normal form");
}
}else{
throw new IllegalStateException("Could not create disjunctiv normal form");
}
}
return (OrFilter) result;
}
/**
* Tests whether the tree is in disjunctive normal form yet.
*
* @return true if the tree is in disjunctive normal form.
*/
private static boolean isInDisjunctiveNormalForm(EventFilter filter) {
/*
* "this" has to be an OrFilter which connects AndFilters which connect Non-LogicaloperationFilters
*/
if (!(filter instanceof OrFilter))
return false;
for (EventFilter operand : ((LogicalOperationFilterImpl) filter).getOperands()) {
if (!(operand instanceof AndFilter))
return false;
for (EventFilter operandsOperand : ((LogicalOperationFilterImpl) operand).getOperands()) {
if (operandsOperand instanceof OrFilter || operandsOperand instanceof AndFilter)
return false;
}
}
return true;
}
/**
* This method traverses the tree recursively and pushes negation to the leafs of the tree using "De Morgan". When the first
* <code>NotFilter</code> is reached, the traversing is being continued using {@link #getNegatedSubTree()}.
*
* @return a filter tree without <code>NotFilter</code>s, which has exactly the same semantics as the original tree.
*/
private static EventFilter eliminateNegations(EventFilter filter) {
// Check if a NotFilter was shall be negated
if (filter instanceof NotFilter) {
// DeMorgan: negate the Terminals (Filter) and replace the connecting OR
// by AND and vice versa (is done in getNegatedSubTree())
EventFilter operand = ((LogicalOperationFilterImpl) filter).getOperands().iterator().next();
// substitue this by the negated subtree
return getNegatedSubTree(operand);
}
// Check if a LogicalOperationFilter shall be negated
if (filter instanceof LogicalOperationFilterImpl) {
// clone list
List<EventFilter> oldOperands = new ArrayList<EventFilter>(((LogicalOperationFilterImpl) filter).getOperands());
// clear original list
((LogicalOperationFilterImpl) filter).clearOperands();
// refill original list
for (EventFilter operand : oldOperands)
addOperand(((LogicalOperationFilterImpl) filter), eliminateNegations(operand));
// no substitution of the filter needed
return filter;
}
// Normal filter are unchanged
return filter;
}
/**
* this method multiplies the boolean expression which the tree represents out in order to get the expanded version. This
* processing is needed in order to achieve a disjunctive normal form. This method is responsible for the recursive
* dispatching an the simplifying of the expanded tree. The real expansion is done in the {@link #multiplyOut(List, int)}
* method.
*
* @return the expanded subtree which did not change any semantics.
*/
static EventFilter getExpandedSubTree(LogicalOperationFilterImpl parent, EventFilter filter) {
if (!(filter instanceof LogicalOperationFilterImpl)) {
return filter;
}
LogicalOperationFilterImpl lof = (LogicalOperationFilterImpl) filter;
// recursively expand subtree
// clone operands
Set<EventFilter> oldOperands = new HashSet<EventFilter>(lof.getOperands().size());
oldOperands.addAll(lof.getOperands());
// clear "new" operands
lof.clearOperands();
/*
* shrink degenerated trees, e.g. an AndFilter that contains only one OrFilter which contains filters is shrinked to the
* AndFilter which then contains the OrFilter's operands
*/
if (oldOperands.size() == 1 && oldOperands.iterator().next() instanceof LogicalOperationFilterImpl) {
if(oldOperands.iterator().next() instanceof AndFilter){
lof = new AndFilter();
}else{
lof = new OrFilter();
}
oldOperands = ((LogicalOperationFilterImpl) oldOperands.iterator().next()).getOperands();
}
for (EventFilter operand : oldOperands) {
EventFilter expandedSubtree = getExpandedSubTree(lof, operand);
if (lof.getClass().equals(expandedSubtree.getClass())) {
/*
* simplify: due to commutativity of logical ORs and ANDs, the operands of the subtree can be added to this's
* operands if the composite LogicalOperationFilter is of the same type
*/
lof.addOperands(((LogicalOperationFilterImpl) expandedSubtree).getOperands());
} else {
addOperand(lof, expandedSubtree);
}
}
boolean isDNFyet = (parent == null && lof.getClass().equals(OrFilter.class));
boolean willBeShrinkedIfNotMultipliedOut = (parent != null && parent.getClass().equals(lof.getClass()));
if (isDNFyet || willBeShrinkedIfNotMultipliedOut)
return lof;
else
return multiplyOut(lof, new LinkedList<LogicalOperationFilterImpl>(), 0);
}
static long getLeafCount(EventFilter f){
if(f instanceof LogicalOperationFilterImpl){
long count =0l;
for(EventFilter o: ((LogicalOperationFilterImpl) f).getOperands()){
count +=getLeafCount(o);
}
return count;
}
return 1l;
}
/**
* transforms a subtree from e.g. (a | b) & (c | d) to (a & c) | (a & d) | (b & c) | (b & d) where a,b,c,d represent instances
* of <code>MoinEventFilter</code>s.
*
* @param intermediateResult
* an empty list - this param is only needed internally
* @param index
* start with 0, this param is only needed internally
* @return the expanded tree.
*/
private static LogicalOperationFilterImpl multiplyOut(LogicalOperationFilterImpl filter,
List<LogicalOperationFilterImpl> intermediateResult, int index) {
// System.out.println("Depth: "+ getDepth(filter) + " Leaves: "+getLeafCount(filter));
List<EventFilter> operands = new ArrayList<EventFilter>(filter.getOperands());
if (operands.size() < 2)
return filter;
/*
* asuming a simple expression (a | b) & (c | d) & (e | f)
*/
if (index == 0) {
// first check, if multiplying out the subtree is possible
boolean moPossible = false;
for (EventFilter operand : operands) {
if (operand instanceof LogicalOperationFilterImpl) {
moPossible = true;
break; // one contained LogicalOperationFilter is enough
}
}
if (!moPossible)
return filter;
Set<EventFilter> tmp1 = null;
if (operands.get(0) instanceof LogicalOperationFilterImpl)
tmp1 = ((LogicalOperationFilterImpl) operands.get(0)).getOperands();
else {
tmp1 = new HashSet<EventFilter>(1);
tmp1.add(operands.get(0));
}
Set<EventFilter> tmp2 = null;
if (operands.get(1) instanceof LogicalOperationFilterImpl)
tmp2 = ((LogicalOperationFilterImpl) operands.get(1)).getOperands();
else {
tmp2 = new HashSet<EventFilter>(1);
tmp2.add(operands.get(1));
}
/*
* take the first 2 expressions ( (a | b) & (c | d) ) and transform them to (a & c) | (a & d) | (b & c) | (b & d)
*/
LogicalOperationFilterImpl lof = null;
for (EventFilter filter1 : tmp1) {
for (EventFilter filter2 : tmp2) {
if (filter instanceof AndFilter) {
lof = new AndFilter(filter1, filter2);
} else {
lof = new OrFilter(filter1, filter2);
}
intermediateResult.add(lof);
}
}
return multiplyOut(filter, intermediateResult, 2);
}
// exit condition
if (index >= operands.size()) {
/*
* the intermediate result is just a list of small trees they have to be connected using a LogicalOperationFilter.
*/
LogicalOperationFilterImpl result;
try {
result = (LogicalOperationFilterImpl) getSubstitutionForLogicalOperation(filter);
} catch (Exception e) {
result = null;
}
for (LogicalOperationFilterImpl lof : intermediateResult)
addOperand(result, lof);
return result;
}
Set<EventFilter> currentOperands = null;
if (operands.get(index) instanceof LogicalOperationFilterImpl) {
currentOperands = ((LogicalOperationFilterImpl) operands.get(index)).getOperands();
} else {
currentOperands = new HashSet<EventFilter>(1);
currentOperands.add(operands.get(index));
}
/*
* for each operand in (e | f) clone the intermediate result ((a & c) | (a & d) | (b & c) | (b & d)) and append e and f
* respectively to each clone. => (a & c & e) | (a & d & e) | (b & c & e) | (b & d & e) | (a & c & f) | (a & d & f) | (b &
* c & f) | (b & d & f)
*/
List<LogicalOperationFilterImpl> irClone = new ArrayList<LogicalOperationFilterImpl>(intermediateResult.size());
irClone.addAll(intermediateResult);
intermediateResult.clear();
for (EventFilter currentOperand : currentOperands) {
for (LogicalOperationFilterImpl currentIntermediateResult : irClone) {
LogicalOperationFilterImpl clone = (LogicalOperationFilterImpl) currentIntermediateResult.clone();
addOperand(clone, currentOperand);
intermediateResult.add(clone);
}
}
return multiplyOut(filter, intermediateResult, index + 1);
}
private static LogicalOperationFilterImpl getSubstitutionForLogicalOperation(LogicalOperationFilterImpl filter) {
if (filter instanceof AndFilter) {
return new OrFilter();
}
if (filter instanceof OrFilter) {
return new AndFilter();
}
throw new IllegalStateException("Unknown logical substitution for " + filter.getClass());
}
/**
* Computes the depth of the subtree. NotFilters are ignored while computing the depth.
*
* @return the maximal depth of the tree.
*/
public static int getDepth(LogicalOperationFilterImpl filter) {
return getDepth(filter, 1);
}
private static int getDepth(LogicalOperationFilterImpl filter, int level) {
int result = 0;
for (EventFilter currentFilter : filter.getOperands()) {
if (currentFilter instanceof LogicalOperationFilterImpl) {
int nextLevel = level + 1;
// Do not count NotFilter
if (currentFilter instanceof NotFilter)
nextLevel = level;
result = Math.max(result, getDepth((LogicalOperationFilterImpl) currentFilter, nextLevel));
}
}
return result + level;
}
/**
* This operation applies the rules of De Morgan in order to return a filter tree which represents the negation of the
* subtree.
*/
private static EventFilter getNegatedSubTree(EventFilter filter) {
if (filter instanceof NotFilter) {
EventFilter result = new ArrayList<EventFilter>(((LogicalOperationFilterImpl) filter).getOperands()).get(0);
// trick in oder to continue the recursion without negating the operand
return getNegatedSubTree(getNegatedSubTree(result));
}
if (filter instanceof LogicalOperationFilterImpl) {
// replace the OrFilter(this) by an AndFilter and negate its operands
LogicalOperationFilterImpl result = getSubstitutionForLogicalOperation((LogicalOperationFilterImpl) filter);
for (EventFilter operand : ((LogicalOperationFilterImpl) filter).getOperands()) {
EventFilter negatedOperand = getNegatedSubTree(operand);
// simplify due to commutativity of AND/OR conjunction
if (negatedOperand.getClass().equals(result.getClass())) {
result.addOperands(((LogicalOperationFilterImpl) negatedOperand).getOperands());
} else {
addOperand(result, negatedOperand);
}
}
return result;
}
// By default simply change the "negated" flag if the EventFilter
((AbstractEventFilter) filter).setNegated(!filter.isNegated());
return filter;
}
/**
* adds the operand to the list if it is not contained yet. Equality of operands is computet by the equality of their
* contained members or operands, not by their reference! This means, that adding two empty AndFilters will result in only one
* AndFilter added for example. Clients that want to evade that functionality can use <code>getOperands().add(..)</code>
* instead.
*
* @param operand
* the operand to add
* @return true if the operand was added
*/
private static boolean addOperand(LogicalOperationFilterImpl filter, EventFilter operand) {
// prevent doubles
filter.addOperand(operand);
return true;
}
public String toString() {
StringBuilder result = new StringBuilder();
result.append("RegistrationManager: (\n");
boolean first = true;
int i=0;
for (TableForEventFilter table : allTables) {
if (!first) {
result.append(",\n");
} else {
first = false;
}
result.append("(");
result.append(i++);
result.append(") ");
result.append(table);
}
result.append(')');
return result.toString();
}
/**
* Creates an array that has length <code>2^{@link #filterTypeToBitMask}.size()</code> so that any combination of
* bit mask used as value in {@link #filterTypeToBitMask} can be used as index into such an array.
*/
@SuppressWarnings("unchecked")
protected Set<Registration>[] createRegistrationSetArray() {
return (Set<Registration>[]) new Set<?>[1<<filterTypeToBitMask.size()];
}
protected void registerTable(TableForEventFilter table, int posInAllTables) {
allTables[posInAllTables] = table;
tableByFilterType.put(table.getIdentifier(), table);
filterTypeToBitMask.put(table.getIdentifier(), 1<<filterTypeToBitMask.size());
tableToIndexInAllTables.put(table, posInAllTables);
}
/**
* When passing a bit set as returned by {@link #getBitSet(Collection)}, returns the collection
* of filter tables identified by this bit set.
*/
protected Collection<TableForEventFilter> getTablesForBitSet(int bitSet) {
Collection<TableForEventFilter> result = new ArrayList<TableForEventFilter>(allTables.length);
int i=1;
for (TableForEventFilter table : allTables) {
if ((bitSet & i) != 0) {
result.add(table);
}
i <<= 1;
}
return result;
}
/**
* Mostly for debugging and analysis. Expects the {@link AndFilter}s to be stored in the {@link Registration}s.
* Scans through all {@link Registration} objects known by this event manager and determines how many overlapping
* distinct registrations with equal {@link AndFilter} there are. This is a prerequisite to judging how much
* of a performance improvement we may gain if we try to collate registrations with equal filters.
*/
public int redundantFilters() {
Map<AndFilter, Registration> distinctAndFilters = new HashMap<AndFilter, Registration>();
int result = 0;
for (Registration ar : allRegistrations.values()) {
if (checkForRedundantFilterAndUpdateMapCorrespondingly((Registration) ar, distinctAndFilters)) {
result++;
}
}
return result;
}
private boolean checkForRedundantFilterAndUpdateMapCorrespondingly(Registration r,
Map<AndFilter, Registration> distinctAndFilters) {
AndFilter andFilter = r.getAndFilter();
boolean result;
Registration knownRegistrationWithEqualAndFilter = distinctAndFilters.get(andFilter);
if (knownRegistrationWithEqualAndFilter == null) {
distinctAndFilters.put(andFilter, r);
result = false;
} else {
result = knownRegistrationWithEqualAndFilter != r;
if (result && knownRegistrationWithEqualAndFilter.getBitSetForTablesRegisteredWith() != r.getBitSetForTablesRegisteredWith()) {
throw new RuntimeException("Error: registrations with equal AndFilter have different bit set, saying they would end up in different tables");
}
}
return result;
}
}