docs: def writeObject(self, obj, is_proxy=False):
          """
          Writes an object to the stream.
          """
          if self.use_proxies and not is_proxy:
              self.writeProxy(obj)
  
              return
  
          self.stream.write(TYPE_OBJECT)
  
          ref = self.context.getObjectReference(obj)
  
          if ref != -1:
              self._writeInteger(ref << 1)
  
              return
  
          self.context.addObject(obj)
  
          # object is not referenced, serialise it
          kls = obj.__class__
          definition = self.context.getClass(kls)
          alias = None
          class_ref = False # if the class definition is a reference
  
          if definition:
              class_ref = True
              alias = definition.alias
          else:
              alias = self.context.getClassAlias(kls)
              definition = ClassDefinition(alias)
  
              self.context.addClass(definition, alias.klass)
  
          if class_ref:
              self.stream.write(definition.reference)
          else:
              ref = 0
  
              if definition.encoding != ObjectEncoding.EXTERNAL:
                  ref += definition.attr_len << 4
  
              final_reference = encode_int(ref | definition.encoding << 2 |
                  REFERENCE_BIT << 1 | REFERENCE_BIT)
  
              self.stream.write(final_reference)
  
              definition.reference = encode_int(
                  definition.reference << 2 | REFERENCE_BIT)
  
              if alias.anonymous:
                  self.stream.write('\x01')
              else:
                  self.serialiseString(alias.alias)
  
              # work out what the final reference for the class will be.
              # this is okay because the next time an object of the same
              # class is encoded, class_ref will be True and never get here
              # again.
  
          if alias.external:
              obj.__writeamf__(DataOutput(self))
  
              return
  
          attrs = alias.getEncodableAttributes(obj, codec=self)
  
          if alias.static_attrs:
              if not class_ref:
                  [self.serialiseString(attr) for attr in alias.static_attrs]
  
              for attr in alias.static_attrs:
                  value = attrs.pop(attr)
  
                  self.writeElement(value)
  
              if definition.encoding == ObjectEncoding.STATIC:
                  return
  
          if definition.encoding == ObjectEncoding.DYNAMIC:
              if attrs:
                  for attr, value in attrs.iteritems():
                      if type(attr) in python.int_types:
                          attr = str(attr)
  
                      self.serialiseString(attr)
                      self.writeElement(value)
  
              self.stream.write('\x01')