code: def register_child(cls, prop, child_cls):
          
          if cls.__subclasses__():
              raise TypeError(
                  "register_child is forbidden on classes with subclasses"
                  " (subclasses: {})".format(
                      ", ".join(map(str, cls.__subclasses__()))
                  ))
  
          if child_cls.TAG in cls.CHILD_MAP:
              raise ValueError("ambiguous Child")
  
          prop.xq_descriptor._register(child_cls)
          cls.CHILD_MAP[child_cls.TAG] = prop.xq_descriptor
docs: Register a new :class:`XMLStreamClass` instance `child_cls` for a given
          :class:`Child` descriptor `prop`.
  
          .. warning::
  
             This method cannot be used after a class has been derived from this
             class. This is for consistency: the method modifies the bookkeeping
             attributes of the class. There would be two ways to deal with the
             situation:
  
             1. Updating all the attributes at all the subclasses and re-evaluate
                the constraints of inheritance. This is simply not implemented,
                although it would be the preferred way.
  
             2. Only update the bookkeeping attributes on *this* class, hiding
                the change from any existing subclasses. New subclasses would
                pick the change up, however, which is inconsistent. This is the
                way which was previously documented here and is not supported
                anymore.
  
             Obviously, (2) is bad, which is why it is not supported anymore. (1)
             might be supported at some point in the future.
  
             Attempting to use :meth:`register_child` on a class which already
             has subclasses results in a :class:`TypeError`.
  
          Note that *first* using :meth:`register_child` and only *then* deriving
          clasess is a valid use: it will still lead to a consistent inheritance
          hierarchy and is a convenient way to break reference cycles (e.g. if an
          XSO may be its own child).