code: def _process_type(self, name, modifiers, contents, module, match):
          
          #First, we need to see if the types children are private.
          if self.RE_PRIV.search(contents):
              modifiers.append("private contents")
  
          #Next, we need to parse out all the members of the type and their docstrings
          members = self.vparser.parse(contents, None)
          
          #Now we can create the type code element and handle the member docstrings
          t = CustomType(name, modifiers, members, module)
          #parse out all the executables including the finalizer
          execs = self._process_execs(contents, module.name, t)
  
          #Set the regex start and end char indices
          t.start, t.end = module.absolute_charindex(match.string, match.start(),
                                                               match.end())
  
          #Update the parent for embedded members and executables
          for key in list(t.members.keys()):
              t.members[key].parent = t
          for key in list(t.executables.keys()):
              t.executables[key].parent = t
  
          #Extract the docstrings from the type body and associate them with their members
          memdocs = self.docparser.parse_docs(contents, t)
          if name in memdocs:
              docs = self.docparser.to_doc(memdocs[name][0], name)
              self.docparser.process_memberdocs(docs, t)
  
          return t
docs: Processes a regex match of a type's contents.