Processes a regex match of a type's contents.

def _process_type(self, name, modifiers, contents, module, match):
        """Processes a regex match of a type's contents."""
        #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