docs: def visit_ClassDef(self, node, **kwargs):
          """
          Handles class definitions within code.
  
          Process the docstring.  Note though that in Python Class definitions
          are used to define interfaces in addition to classes.
          If a class definition appears to be an interface definition tag it as an
          interface definition for Doxygen.  Otherwise tag it as a class
          definition for Doxygen.
          """
          lineNum = node.lineno - 1
          # Push either 'interface' or 'class' onto our containing nodes
          # hierarchy so we can keep track of context.  This will let us tell
          # if a function is a method or an interface method definition or if
          # a class is fully contained within another class.
          containingNodes = kwargs.get('containingNodes') or []
  
          if not self.options.object_respect:
              # Remove object class of the inherited class list to avoid that all
              # new-style class inherits from object in the hierarchy class
              line = self.lines[lineNum]
              match = AstWalker.__classRE.match(line)
              if match:
                  if match.group(2) == 'object':
                      self.lines[lineNum] = line[:match.start(2)] + line[match.end(2):]
  
          match = AstWalker.__interfaceRE.match(self.lines[lineNum])
          if match:
              if self.options.debug:
                  stderr.write("# Interface {0.name}{1}".format(node, linesep))
              containingNodes.append((node.name, 'interface'))
          else:
              if self.options.debug:
                  stderr.write("# Class {0.name}{1}".format(node, linesep))
              containingNodes.append((node.name, 'class'))
          if self.options.topLevelNamespace:
              fullPathNamespace = self._getFullPathName(containingNodes)
              contextTag = '.'.join(pathTuple[0] for pathTuple in fullPathNamespace)
              tail = '@namespace {0}'.format(contextTag)
          else:
              tail = ''
          # Class definitions have one Doxygen-significant special case:
          # interface definitions.
          if match:
              contextTag = '{0}{1}# @interface {2}'.format(tail,
                                                           linesep,
                                                           match.group(1))
          else:
              contextTag = tail
          contextTag = self._processMembers(node, contextTag)
          if get_docstring(node):
              self._processDocstring(node, contextTag,
                                     containingNodes=containingNodes)
          # Visit any contained nodes.
          self.generic_visit(node, containingNodes=containingNodes)
          # Remove the item we pushed onto the containing nodes hierarchy.
          containingNodes.pop()