A Registration represents an AndFilter with only elementary or negated
elementary filters. (In a future version, a Registration can represent
multiple equal such AndFilters.)

A Registration is entered into all tables for whose type its AndFilter
contains an elementary filter.

Each table maps a value for the filter criterion to a YesSet and a
NoSet. The YesSet contains all Registrations where a non-negated
elementary filter for the key criterion occurred. The NoSet contains
all Registrations where a negated elementary filter for the key
criterion occurred.

When an event occurs, it matches a Registration if and only if all
(negated and non-negated) elementary filters of the registration are
matched. This means that:

 - if a Registration is in table t's YesSet, it MUST be matched by the
   event e (R1). This in particular requires that e affects t.

 - if a Registration is in a table t's NoSet, it MUST NOT be matched by
   the event e (R2). This is in particular the case if e does not
   affect t.

Formally, we can define a test function that for a given Registration
r and a given event e determines if the Registration if matched by the
event:

   matches(r, e) := tables->forAll(t |
                       (t.allYes->includes(r) implies
                         (t.yes(e)->includes(r) and t.affectedBy(e)))
                  and  (t.allNo->includes(r) implies
                         (not t.affectedBy(e) or not t.no(e)->includes(r))))

Transformed:

   matches(r, e) := tables->forAll(t | matches(t, r, e))
   matches(t, r, e) :=
		(not t.allYes->includes(r) or t.yes(e)->includes(r) and t.affectedBy(e))
	and	(not t.allNo->includes(r) or not (t.no(e)->includes(r) and t.affectedBy(e)))

which shows that registrations neither in the allYes nor allNo of a
table t are matched by that table.

Thinking in sets, the set of registrations matching e is the
intersection of the sets of registrations matched by each table. The
problem with this definition is only that the "universe" of all
registrations to be considered is the union of all allYes and allNo
sets of all tables, computing which would be inefficient.


The challenge now is to compute all r for a given event e for which
matches(r, e) holds. Fast operations (O(1)) are t.allNo, t.allYes,
t.yes(e), t.no(e), also t.affectedBy(e). The number of Registrations r
may be large, and so may be t.allYes, t.allNo, t.yes(e) and t.no(e),
although typically t.allNo is fairly small, and so is t.no(e),
particularly in the context of the OCL impact analysis.

We also know that the union of t.allYes->union(t.allNo) over all
tables t results in the complete set of all Registrations. In other
words, each Registration to be considered is in the allYes or allNo
set of at least one table. The number of tables is constant and fairly
small (usually <10).

We are looking for a function

    registrations(e) := all registrations r such that matches(r, e)

that can be computed efficiently.


TODO Special handling for multi-registrations, such as for multiple
classes in the class filter table: In this case the Registration is
matched if any of the multiple criteria are matched by the event. TODO
What happens for a negated filter that would expand to multiple
criteria?