niess.dispatch¶

def register(self, source: type | str):
    """Register against a niess class (or its dotted ``source_type`` name)."""
    source_type = source if isinstance(source, str) else niess_source_type(source)

    def decorator(func: B) -> B:
        self._source_type_builders[source_type] = func
        return func

    return decorator

def register_role(self, role: str):
    """Register against a provenance ``role``."""
    def decorator(func: B) -> B:
        self._role_builders[role] = func
        return func

    return decorator

def register_component_type(self, *comp_type_names: str):
    """Register against one or more raw McCode component-type names."""
    def decorator(func: B) -> B:
        for name in comp_type_names:
            self._component_type_builders[name] = func
        return func

    return decorator

def resolve_builder(self, instance) -> B | None:
    """Return the builder for ``instance``, or ``None`` if none is registered.

    This registry's own three tiers are tried first, in full, before any parent
    is consulted: the more specific registry wins outright.

    ``None`` means *unhandled* -- it never means "handled, emit nothing".
    Callers that need that distinction must invoke the returned builder
    themselves and interpret its return value.
    """
    provenance = NiessProvenance.from_instance(instance)
    builder = self._resolve_local(instance, provenance)
    if builder is not None:
        return builder
    return None if self.parent is None else self.parent.resolve_builder(instance)

def resolve_for_object(self, obj) -> B | None:
    """Return the builder for a niess *object*, or ``None`` if none is registered.

    The companion to :meth:`resolve_builder`, which resolves against an emitted
    McStas instance. Same tiers, read off the object rather than off a metadata blob
    it left behind, most specific first:

    1. a translator registered for the object's exact class,
    2. the object's own hooks for this target, if it has any (see
       :class:`ClassHooks`) -- as specific as (1), because a class describing its own
       conversion is describing *its* conversion,
    3. a translator registered for an ancestor class, nearest first,
    4. a translator registered for the object's role.

    A registration for a base class does not beat a hook on the class itself:
    registering something for ``Component`` says what to do with components in
    general, and a component that says what to do with itself is more specific than
    that.

    There is no McCode-component-type tier: a type name is something an object
    acquires by being emitted, and nothing here has been.

    As everywhere else, ``None`` means *unhandled*; it never means "handled, emit
    nothing".
    """
    exact = self._exact(obj)
    if exact is not None:
        return exact
    if self.hooks is not None and self._defines_hooks(type(obj)):
        return ClassHooks(obj, self.hooks)
    return self._inherited(obj)

def registered_component_types(self) -> frozenset[str]:
    """Component-type names this registry handles, inherited ones included."""
    inherited = frozenset() if self.parent is None else self.parent.registered_component_types()
    return frozenset(self._component_type_builders) | inherited