docs: def write_object(self, obj, parent=None):
          """
          Writes an object header to the serialization stream
  
          :param obj: Not yet used
          :param parent: Not yet used
          """
          # Transform object
          for transformer in self.object_transformers:
              tmp_object = transformer.transform(obj)
              if tmp_object is not obj:
                  obj = tmp_object
                  break
  
          self._writeStruct(">B", 1, (self.TC_OBJECT,))
          cls = obj.get_class()
          self.write_classdesc(cls)
  
          # Add reference
          self.references.append([])
          logging.debug(
              "*** Adding ref 0x%X for object %s",
              len(self.references) - 1 + self.BASE_REFERENCE_IDX,
              obj,
          )
  
          all_names = collections.deque()
          all_types = collections.deque()
          tmpcls = cls
          while tmpcls:
              all_names.extendleft(reversed(tmpcls.fields_names))
              all_types.extendleft(reversed(tmpcls.fields_types))
              tmpcls = tmpcls.superclass
          del tmpcls
  
          logging.debug("<=> Field names: %s", all_names)
          logging.debug("<=> Field types: %s", all_types)
  
          for field_name, field_type in zip(all_names, all_types):
              try:
                  logging.debug(
                      "Writing field %s (%s): %s",
                      field_name,
                      field_type,
                      getattr(obj, field_name),
                  )
                  self._write_value(field_type, getattr(obj, field_name))
              except AttributeError as ex:
                  log_error(
                      "No attribute {0} for object {1}\nDir: {2}".format(
                          ex, repr(obj), dir(obj)
                      )
                  )
                  raise
          del all_names, all_types
  
          if (
              cls.flags & self.SC_SERIALIZABLE
              and cls.flags & self.SC_WRITE_METHOD
              or cls.flags & self.SC_EXTERNALIZABLE
              and cls.flags & self.SC_BLOCK_DATA
          ):
              for annotation in obj.annotations:
                  log_debug(
                      "Write annotation {0} for {1}".format(repr(annotation), repr(obj))
                  )
                  if annotation is None:
                      self.write_null()
                  else:
                      self.writeObject(annotation)
              self._writeStruct(">B", 1, (self.TC_ENDBLOCKDATA,))