# Source code for brian2.core.tracking

    from collections import defaultdict
    from weakref import ref

    __all__ = ["Trackable"]

    class InstanceTrackerSet(set):
        """
        A `set` of `weakref.ref` to all existing objects of a certain class.

        Should not normally be directly used.
        """

        def add(self, value):
            """
            Adds a `weakref.ref` to the ``value``
            """
            # The second argument to ref is a callback that is called with the
            # ref as argument when the object has been deleted, here we just
            # remove it from the set in that case
            wr = ref(value, self.remove)
            set.add(self, wr)

        def remove(self, value):
            """
            Removes the ``value`` (which should be a weakref) if it is in the set

            Sometimes the value will have been removed from the set by `clear`,
            so we ignore `KeyError` in this case.
            """
            try:
                set.remove(self, value)
            except KeyError:
                pass

    class InstanceFollower:
        """
        Keep track of all instances of classes derived from `Trackable`

        The variable ``__instancesets__`` is a dictionary with keys which are class
        objects, and values which are `InstanceTrackerSet`, so
        ``__instanceset__[cls]`` is a set tracking all of the instances of class
        ``cls`` (or a subclass).
        """

        instance_sets = defaultdict(InstanceTrackerSet)

        def add(self, value):
            for cls in value.__class__.__mro__:  # MRO is the Method Resolution Order which contains all the superclasses of a class
                self.instance_sets[cls].add(value)

        def get(self, cls):
            return self.instance_sets[cls]

    class Trackable:
        """
        Classes derived from this will have their instances tracked.

        The `classmethod` `__instances__()` will return an `InstanceTrackerSet`
        of the instances of that class, and its subclasses.
        """

        __instancefollower__ = (
            InstanceFollower()
        )  # static property of all objects of class derived from Trackable

        def __new__(typ, *args, **kw):
            obj = object.__new__(typ)
            obj.__instancefollower__.add(obj)
            return obj

        @classmethod
        def __instances__(cls):
            return cls.__instancefollower__.get(cls)