'Computes all matches for a given input
:param input_string: the string to parse
:type input_string: str
:param context: the context
:type context: dict
:param with_raw_matches: should return details
:type with_raw_matches: dict
:return: matches based on input_string for this pattern
:rtype: iterator[Match]'

def matches(self, input_string, context=None, with_raw_matches=False):

    matches = []
    raw_matches = []
    for pattern in self.patterns:
        yield_parent = self._yield_parent()
        match_index = (-1)
        for match in self._match(pattern, input_string, context):
            match_index += 1
            match.match_index = match_index
            raw_matches.append(match)
            yield_children = self._yield_children(match)
            if (not self._match_parent(match, yield_parent)):
                continue
            validated = True
            for child in match.children:
                if (not self._match_child(child, yield_children)):
                    validated = False
                    break
            if validated:
                if self.private_parent:
                    match.private = True
                if self.private_children:
                    for child in match.children:
                        child.private = True
                if (yield_parent or self.private_parent):
                    matches.append(match)
                if (yield_children or self.private_children):
                    for child in match.children:
                        child.match_index = match_index
                        matches.append(child)
    self._matches_privatize(matches)
    self._matches_ignore(matches)
    if with_raw_matches:
        return (matches, raw_matches)
    return matches
