Matcher (MRules Javadoc 2.7.0 API)

All Superinterfaces:

Serializable

All Known Implementing Classes:

AbstractCombineLexerMatcher.AbstractCombineMatcher, AbstractGenericMatcher, AbstractGenericTextMatcher, AbstractMatcher, AbstractMatcherWrapper, AndLexerMatcher.AndMatcher, FixedLexerMatcher.FixedMatcher, LexerBlockMatcher.BlockMatcher, MultipleFixedLexerMatcher.MultipleFixedMatcher, OrLexerMatcher.OrMatcher, RegexLexerMatcher.RegexMatcher
```
public interface Matcher
extends Serializable
```
Matcher for which an instance is dedicated to a specific match.
Obtained with the LexerMatcher.getMatcher(com.massa.dsl.lexer.LexerParser) method.

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`boolean`	`equivalent(Matcher obj)` Equality without start mark, when equality should check LexerMatcher and start mark.
`List<ParsingContext.AutoCompleteResult>`	`getAutoCompleteOptions(MatchingPhase phase)` Computes autoComplete options from current partial matches, if any.
`int`	`getEffectiveStartMark()`
`int`	`getEndMark()`
`Pattern`	`getFollowingCharPattern()`
`CharPatternMatchResult`	`getFollowingCharPatternMatchResult()`
`Grammar`	`getGrammar()`
`LexerMatcher`	`getLexerMatcher()`
`LexerParser`	`getLexerParser()`
`String`	`getMatchedText()` Retrieves text between start of match and end of match.
`ParsingContext`	`getParsingContext()`
`Pattern`	`getPreviousCharPattern()`
`CharPatternMatchResult`	`getPreviousCharPatternMatchResult()`
`AdvancedReader`	`getSource()`
`int`	`getStartMark()`
`Integer`	`getWeight()`
`void`	`injectResult(Object target)` If the matcher (or one or several of the matchers in the chain) generates an Object, this allows to inject it (or them) into the result.
`boolean`	`isAutoCompletePossible()` Considering match result, tells if autoComplete is possible or not (i.e. if options should be searched or not).
`boolean`	`isExcludedFromHierarchy(Matcher matcher)` Tells if provided sub matcher should be excluded from matching hierarchy.
`boolean`	`isExclusionHierarchyBreaker()` Tells if this matcher should break search for exclusion in older hierarchy.
`Boolean`	`isMatched()`
`boolean`	`isSkipMatchText()`
`int`	`match(MatchingPhase phase, boolean unread)` Tells if this match pattern matches the next characters of the source.
`void`	`toBeginParse()` Replaces the source at its state to where the parsing process should begin.
`void`	`toEndOfMatch()` Replaces the source at its state after match ended if successful.
`void`	`toStartOfMatch()` Replaces the source at its state before match started.

- Method Detail
  - match
```
int match(MatchingPhase phase,
          boolean unread)
   throws IOException,
          DslException
```
    Tells if this match pattern matches the next characters of the source.
    Returns the match weight, which typically consists in returning the number of useful matching character.
    If match already performed once, does nothing and returns the previously computed weight.
    
    Parameters:
    
    phase - Phase when the matching is performed.
    
    unread - Tells if the source should be replaced at start after the match operation or not. If match fails, this parameter is ignored and source is unread.
    
    Returns:
    
    < 0 if not matched, the match weight otherwise.
    
    Throws:
    
    IOException
    
    DslException
  - getAutoCompleteOptions
```
List<ParsingContext.AutoCompleteResult> getAutoCompleteOptions(MatchingPhase phase)
                                                        throws IOException,
                                                               DslException
```
    Computes autoComplete options from current partial matches, if any.
    This method can't be invoked if match has not been done.
    
    Parameters:
    
    phase - Phase when the matching is performed.
    
    Returns:
    
    AutoComplete options
    
    Throws:
    
    IOException
    
    DslException
  - isAutoCompletePossible
```
boolean isAutoCompletePossible()
                        throws DslException
```
    Considering match result, tells if autoComplete is possible or not (i.e. if options should be searched or not).
    
    Returns:
    
    true if possible
    
    Throws:
    
    DslException
  - isMatched
```
Boolean isMatched()
```
    Returns:
    
    true if match OK, false if match KO, null if match not performed.
  - getPreviousCharPatternMatchResult
```
CharPatternMatchResult getPreviousCharPatternMatchResult()
```
    Returns:
    
    Result of match of PreviousCharPattern on the previous character, null if match not performed.
  - getFollowingCharPatternMatchResult
```
CharPatternMatchResult getFollowingCharPatternMatchResult()
```
    Returns:
    
    Result of match of FollowingCharPattern on the next character, null if match not performed.
  - getWeight
```
Integer getWeight()
```
    Returns:
    
    weight computed by match operation. If not performed, returns null.
  - getStartMark
```
int getStartMark()
```
    Returns:
    
    Input source mark positionned at matching process start.
  - getEffectiveStartMark
```
int getEffectiveStartMark()
```
    Returns:
    
    Input source mark positionned at matching process start, just after unuseful characters were skipped.
  - getEndMark
```
int getEndMark()
```
    Returns:
    
    Input source mark positionned at matching process end, if match is successful.
  - toStartOfMatch
```
void toStartOfMatch()
```
    Replaces the source at its state before match started.
    If no match has been made or source is already at start position, it has no effect.
  - toEndOfMatch
```
void toEndOfMatch()
```
    Replaces the source at its state after match ended if successful.
    If no match has been made or it failed or source is already at end position, it has no effect.
  - getMatchedText
```
String getMatchedText()
               throws IOException
```
    Retrieves text between start of match and end of match.
    
    Throws:
    
    IOException
  - toBeginParse
```
void toBeginParse()
```
    Replaces the source at its state to where the parsing process should begin.
    This position is in general at end of match, or at begin. But it could be anywhere in the matched part in theory.
    If no match has been made or it failed or source is already at end position, it has no effect.
  - injectResult
```
void injectResult(Object target)
           throws DslException
```
    If the matcher (or one or several of the matchers in the chain) generates an Object, this allows to inject it (or them) into the result.
    This method should be called by the concerned lexers.
    
    Parameters:
    
    target -
    
    Throws:
    
    DslException
  - getLexerMatcher
```
LexerMatcher getLexerMatcher()
```
    Returns:
    
    The owning lexer matcher
  - getLexerParser
```
LexerParser getLexerParser()
```
    Returns:
    
    The owning lexer parser
  - getParsingContext
```
ParsingContext getParsingContext()
```
    Returns:
    
    The current parsing context for this parsing process
  - getGrammar
```
Grammar getGrammar()
```
    Returns:
    
    The grammar defining the source structure
  - getSource
```
AdvancedReader getSource()
```
    Returns:
    
    The source currently being parsed
  - isExcludedFromHierarchy
```
boolean isExcludedFromHierarchy(Matcher matcher)
                         throws DslException
```
    Tells if provided sub matcher should be excluded from matching hierarchy.
    
    Parameters:
    
    matcher -
    
    Returns:
    
    true if should be excluded
    
    Throws:
    
    DslException
  - equivalent
```
boolean equivalent(Matcher obj)
```
    Equality without start mark, when equality should check LexerMatcher and start mark.
    
    Parameters:
    
    obj -
    
    Returns:
    
    true if equivalent
  - getPreviousCharPattern
```
Pattern getPreviousCharPattern()
```
    Returns:
    
    Regex Pattern to which the previous character must match, or null if unspecified.
    This method can use the LexerMatcher equivalent method as a default, or recompute the result depending on the current matching situation.
    Please note that the provided regex must apply to a single character, otherwise it will never match.
  - getFollowingCharPattern
```
Pattern getFollowingCharPattern()
```
    Returns:
    
    Regex Pattern to which the following character must match, or null if unspecified.
    This method can use the LexerMatcher equivalent method as a default, or recompute the result depending on the current matching situation. Please note that the provided regex must apply to a single character, otherwise it will never match.
  - isSkipMatchText
```
boolean isSkipMatchText()
```
    Returns:
    
    true if matched text must be skipped or unread to be provided to the parser.
    This method can use the LexerMatcher equivalent method as a default, or recompute the result depending on the current matching situation.
  - isExclusionHierarchyBreaker
```
boolean isExclusionHierarchyBreaker()
```
    Tells if this matcher should break search for exclusion in older hierarchy.
    Typically, the AndLexerMatcher is concerned.

Interface Matcher

Method Summary

Method Detail

match

getAutoCompleteOptions

isAutoCompletePossible

isMatched

getPreviousCharPatternMatchResult

getFollowingCharPatternMatchResult

getWeight

getStartMark

getEffectiveStartMark

getEndMark

toStartOfMatch

toEndOfMatch

getMatchedText

toBeginParse

injectResult

getLexerMatcher

getLexerParser

getParsingContext

getGrammar

getSource

isExcludedFromHierarchy

equivalent

getPreviousCharPattern

getFollowingCharPattern

isSkipMatchText

isExclusionHierarchyBreaker