ProtectedfulfilledRemembers whether all TypeReferences are in the desired states (true) or not (false).
Protected ReadonlylistenersThese listeners will be informed once, when all TypeReferences are in the desired state. If some of these TypeReferences are invalid (the listeners will not be informed about this) and later in the desired state again, the listeners will be informed again, and so on.
ProtectedtypesThis is required for cyclic type definitions: In case of two types A, B which use each other for their properties (e.g. class A {p: B} and class B {p: A}), the case easily occurs, that the types A and B (respectively their WaitingFor... instances) are waiting for each other and therefore waiting for each other. In order to solve these cycles, types which are part of such "dependency cycles" should be ignored during waiting, e.g. A should not waiting B and B should not wait for A. These types to ignore are stored in the following Set.
Protected ReadonlywaitThese TypeReferences must be in the state Completed, before the listeners are informed
Protected ReadonlywaitThese TypeReferences must be in the states Identifiable or Completed, before the listeners are informed
This method is called to inform about additional types which can be ignored during the waiting/resolving process. This helps to deal with cycles in type dependencies.
might contain duplicates, which are filtered internally
ProtectedcheckInforms when the type of the reference is invalidated/removed.
the currently invalidate/unresolved TypeReference
undefined occurs in the special case, that the TypeReference never resolved a type so far, but new listeners already want to be informed about the (current) type.
Informs when the type of the reference is resolved/found.
the currently resolved TypeReference
Usually the resolved type is either 'Identifiable' or 'Completed', in rare cases this type might be 'Invalid', e.g. if there are corresponding inference rules or TypeInitializers.
Protectedswitch
The purpose of this class is to inform its listeners, when all given TypeReferences reached their specified initialization state (or a later state). After that, the listeners might be informed multiple times, if at least one of the TypeReferences was unresolved/invalid, but later on all TypeReferences are again in the desired state, and so on.