MatcherFluent (Fabric8 :: Chaos Mesh

All Superinterfaces:

io.fabric8.kubernetes.api.builder.Fluent<A>

All Known Subinterfaces:

ChaosmeshSchemaFluent.GithubComChaosMeshChaosMeshApiV1alpha1MatcherNested<N>, HTTPChaosSpecFluent.HeadersNested<N>

All Known Implementing Classes:

ChaosmeshSchemaFluentImpl.GithubComChaosMeshChaosMeshApiV1alpha1MatcherNestedImpl, HTTPChaosSpecFluentImpl.HeadersNestedImpl, MatcherBuilder, MatcherFluentImpl
```
public interface MatcherFluent<A extends MatcherFluent<A>>
extends io.fabric8.kubernetes.api.builder.Fluent<A>
```

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`String`	`getExactMatch()`
`String`	`getInvertMatch()`
`String`	`getName()`
`String`	`getPrefixMatch()`
`String`	`getPresentMatch()`
`String`	`getRangeMatch()`
`String`	`getRegexMatch()`
`String`	`getSafeRegexMatch()`
`String`	`getSuffixMatch()`
`Boolean`	`hasExactMatch()`
`Boolean`	`hasInvertMatch()`
`Boolean`	`hasName()`
`Boolean`	`hasPrefixMatch()`
`Boolean`	`hasPresentMatch()`
`Boolean`	`hasRangeMatch()`
`Boolean`	`hasRegexMatch()`
`Boolean`	`hasSafeRegexMatch()`
`Boolean`	`hasSuffixMatch()`
`A`	`withExactMatch(String exactMatch)`
`A`	`withInvertMatch(String invertMatch)`
`A`	`withName(String name)`
`A`	`withNewExactMatch(byte[] arg1)`
`A`	`withNewExactMatch(byte[] arg1, int arg2)`
`A`	`withNewExactMatch(byte[] arg1, int arg2, int arg3)`
`A`	`withNewExactMatch(byte[] arg1, int arg2, int arg3, int arg4)`
`A`	`withNewExactMatch(char[] arg1)`
`A`	`withNewExactMatch(char[] arg1, int arg2, int arg3)`
`A`	`withNewExactMatch(int[] arg1, int arg2, int arg3)`
`A`	`withNewExactMatch(String arg1)`
`A`	`withNewExactMatch(StringBuffer arg1)`
`A`	`withNewExactMatch(StringBuilder arg1)`
`A`	`withNewInvertMatch(byte[] arg1)`
`A`	`withNewInvertMatch(byte[] arg1, int arg2)`
`A`	`withNewInvertMatch(byte[] arg1, int arg2, int arg3)`
`A`	`withNewInvertMatch(byte[] arg1, int arg2, int arg3, int arg4)`
`A`	`withNewInvertMatch(char[] arg1)`
`A`	`withNewInvertMatch(char[] arg1, int arg2, int arg3)`
`A`	`withNewInvertMatch(int[] arg1, int arg2, int arg3)`
`A`	`withNewInvertMatch(String arg1)`
`A`	`withNewInvertMatch(StringBuffer arg1)`
`A`	`withNewInvertMatch(StringBuilder arg1)`
`A`	`withNewName(byte[] arg1)`
`A`	`withNewName(byte[] arg1, int arg2)`
`A`	`withNewName(byte[] arg1, int arg2, int arg3)`
`A`	`withNewName(byte[] arg1, int arg2, int arg3, int arg4)`
`A`	`withNewName(char[] arg1)`
`A`	`withNewName(char[] arg1, int arg2, int arg3)`
`A`	`withNewName(int[] arg1, int arg2, int arg3)`
`A`	`withNewName(String arg1)`
`A`	`withNewName(StringBuffer arg1)`
`A`	`withNewName(StringBuilder arg1)`
`A`	`withNewPrefixMatch(byte[] arg1)`
`A`	`withNewPrefixMatch(byte[] arg1, int arg2)`
`A`	`withNewPrefixMatch(byte[] arg1, int arg2, int arg3)`
`A`	`withNewPrefixMatch(byte[] arg1, int arg2, int arg3, int arg4)`
`A`	`withNewPrefixMatch(char[] arg1)`
`A`	`withNewPrefixMatch(char[] arg1, int arg2, int arg3)`
`A`	`withNewPrefixMatch(int[] arg1, int arg2, int arg3)`
`A`	`withNewPrefixMatch(String arg1)`
`A`	`withNewPrefixMatch(StringBuffer arg1)`
`A`	`withNewPrefixMatch(StringBuilder arg1)`
`A`	`withNewPresentMatch(byte[] arg1)`
`A`	`withNewPresentMatch(byte[] arg1, int arg2)`
`A`	`withNewPresentMatch(byte[] arg1, int arg2, int arg3)`
`A`	`withNewPresentMatch(byte[] arg1, int arg2, int arg3, int arg4)`
`A`	`withNewPresentMatch(char[] arg1)`
`A`	`withNewPresentMatch(char[] arg1, int arg2, int arg3)`
`A`	`withNewPresentMatch(int[] arg1, int arg2, int arg3)`
`A`	`withNewPresentMatch(String arg1)`
`A`	`withNewPresentMatch(StringBuffer arg1)`
`A`	`withNewPresentMatch(StringBuilder arg1)`
`A`	`withNewRangeMatch(byte[] arg1)`
`A`	`withNewRangeMatch(byte[] arg1, int arg2)`
`A`	`withNewRangeMatch(byte[] arg1, int arg2, int arg3)`
`A`	`withNewRangeMatch(byte[] arg1, int arg2, int arg3, int arg4)`
`A`	`withNewRangeMatch(char[] arg1)`
`A`	`withNewRangeMatch(char[] arg1, int arg2, int arg3)`
`A`	`withNewRangeMatch(int[] arg1, int arg2, int arg3)`
`A`	`withNewRangeMatch(String arg1)`
`A`	`withNewRangeMatch(StringBuffer arg1)`
`A`	`withNewRangeMatch(StringBuilder arg1)`
`A`	`withNewRegexMatch(byte[] arg1)`
`A`	`withNewRegexMatch(byte[] arg1, int arg2)`
`A`	`withNewRegexMatch(byte[] arg1, int arg2, int arg3)`
`A`	`withNewRegexMatch(byte[] arg1, int arg2, int arg3, int arg4)`
`A`	`withNewRegexMatch(char[] arg1)`
`A`	`withNewRegexMatch(char[] arg1, int arg2, int arg3)`
`A`	`withNewRegexMatch(int[] arg1, int arg2, int arg3)`
`A`	`withNewRegexMatch(String arg1)`
`A`	`withNewRegexMatch(StringBuffer arg1)`
`A`	`withNewRegexMatch(StringBuilder arg1)`
`A`	`withNewSafeRegexMatch(byte[] arg1)`
`A`	`withNewSafeRegexMatch(byte[] arg1, int arg2)`
`A`	`withNewSafeRegexMatch(byte[] arg1, int arg2, int arg3)`
`A`	`withNewSafeRegexMatch(byte[] arg1, int arg2, int arg3, int arg4)`
`A`	`withNewSafeRegexMatch(char[] arg1)`
`A`	`withNewSafeRegexMatch(char[] arg1, int arg2, int arg3)`
`A`	`withNewSafeRegexMatch(int[] arg1, int arg2, int arg3)`
`A`	`withNewSafeRegexMatch(String arg1)`
`A`	`withNewSafeRegexMatch(StringBuffer arg1)`
`A`	`withNewSafeRegexMatch(StringBuilder arg1)`
`A`	`withNewSuffixMatch(byte[] arg1)`
`A`	`withNewSuffixMatch(byte[] arg1, int arg2)`
`A`	`withNewSuffixMatch(byte[] arg1, int arg2, int arg3)`
`A`	`withNewSuffixMatch(byte[] arg1, int arg2, int arg3, int arg4)`
`A`	`withNewSuffixMatch(char[] arg1)`
`A`	`withNewSuffixMatch(char[] arg1, int arg2, int arg3)`
`A`	`withNewSuffixMatch(int[] arg1, int arg2, int arg3)`
`A`	`withNewSuffixMatch(String arg1)`
`A`	`withNewSuffixMatch(StringBuffer arg1)`
`A`	`withNewSuffixMatch(StringBuilder arg1)`
`A`	`withPrefixMatch(String prefixMatch)`
`A`	`withPresentMatch(String presentMatch)`
`A`	`withRangeMatch(String rangeMatch)`
`A`	`withRegexMatch(String regexMatch)`
`A`	`withSafeRegexMatch(String safeRegexMatch)`
`A`	`withSuffixMatch(String suffixMatch)`

Method Detail

getExactMatch
```
String getExactMatch()
```

withExactMatch
```
A withExactMatch(String exactMatch)
```

hasExactMatch
```
Boolean hasExactMatch()
```

withNewExactMatch

A withNewExactMatch(StringBuilder arg1)

withNewExactMatch

A withNewExactMatch(int[] arg1,
                    int arg2,
                    int arg3)

withNewExactMatch
```
A withNewExactMatch(char[] arg1)
```

withNewExactMatch

A withNewExactMatch(StringBuffer arg1)

withNewExactMatch

A withNewExactMatch(byte[] arg1,
                    int arg2)

withNewExactMatch
```
A withNewExactMatch(byte[] arg1)
```

withNewExactMatch

A withNewExactMatch(char[] arg1,
                    int arg2,
                    int arg3)

withNewExactMatch

A withNewExactMatch(byte[] arg1,
                    int arg2,
                    int arg3)

withNewExactMatch

A withNewExactMatch(byte[] arg1,
                    int arg2,
                    int arg3,
                    int arg4)

withNewExactMatch
```
A withNewExactMatch(String arg1)
```

getInvertMatch
```
String getInvertMatch()
```

withInvertMatch
```
A withInvertMatch(String invertMatch)
```

hasInvertMatch
```
Boolean hasInvertMatch()
```

withNewInvertMatch

A withNewInvertMatch(StringBuilder arg1)

withNewInvertMatch

A withNewInvertMatch(int[] arg1,
                     int arg2,
                     int arg3)

withNewInvertMatch
```
A withNewInvertMatch(char[] arg1)
```

withNewInvertMatch

A withNewInvertMatch(StringBuffer arg1)

withNewInvertMatch

A withNewInvertMatch(byte[] arg1,
                     int arg2)

withNewInvertMatch
```
A withNewInvertMatch(byte[] arg1)
```

withNewInvertMatch

A withNewInvertMatch(char[] arg1,
                     int arg2,
                     int arg3)

withNewInvertMatch

A withNewInvertMatch(byte[] arg1,
                     int arg2,
                     int arg3)

withNewInvertMatch

A withNewInvertMatch(byte[] arg1,
                     int arg2,
                     int arg3,
                     int arg4)

withNewInvertMatch
```
A withNewInvertMatch(String arg1)
```

getName
```
String getName()
```

withName
```
A withName(String name)
```

hasName
```
Boolean hasName()
```

withNewName
```
A withNewName(StringBuilder arg1)
```

withNewName

A withNewName(int[] arg1,
              int arg2,
              int arg3)

withNewName
```
A withNewName(char[] arg1)
```

withNewName
```
A withNewName(StringBuffer arg1)
```

withNewName

A withNewName(byte[] arg1,
              int arg2)

withNewName
```
A withNewName(byte[] arg1)
```

withNewName

A withNewName(char[] arg1,
              int arg2,
              int arg3)

withNewName

A withNewName(byte[] arg1,
              int arg2,
              int arg3)

withNewName

A withNewName(byte[] arg1,
              int arg2,
              int arg3,
              int arg4)

withNewName
```
A withNewName(String arg1)
```

getPrefixMatch
```
String getPrefixMatch()
```

withPrefixMatch
```
A withPrefixMatch(String prefixMatch)
```

hasPrefixMatch
```
Boolean hasPrefixMatch()
```

withNewPrefixMatch

A withNewPrefixMatch(StringBuilder arg1)

withNewPrefixMatch

A withNewPrefixMatch(int[] arg1,
                     int arg2,
                     int arg3)

withNewPrefixMatch
```
A withNewPrefixMatch(char[] arg1)
```

withNewPrefixMatch

A withNewPrefixMatch(StringBuffer arg1)

withNewPrefixMatch

A withNewPrefixMatch(byte[] arg1,
                     int arg2)

withNewPrefixMatch
```
A withNewPrefixMatch(byte[] arg1)
```

withNewPrefixMatch

A withNewPrefixMatch(char[] arg1,
                     int arg2,
                     int arg3)

withNewPrefixMatch

A withNewPrefixMatch(byte[] arg1,
                     int arg2,
                     int arg3)

withNewPrefixMatch

A withNewPrefixMatch(byte[] arg1,
                     int arg2,
                     int arg3,
                     int arg4)

withNewPrefixMatch
```
A withNewPrefixMatch(String arg1)
```

getPresentMatch
```
String getPresentMatch()
```

withPresentMatch

A withPresentMatch(String presentMatch)

hasPresentMatch
```
Boolean hasPresentMatch()
```

withNewPresentMatch

A withNewPresentMatch(StringBuilder arg1)

withNewPresentMatch

A withNewPresentMatch(int[] arg1,
                      int arg2,
                      int arg3)

withNewPresentMatch
```
A withNewPresentMatch(char[] arg1)
```

withNewPresentMatch

A withNewPresentMatch(StringBuffer arg1)

withNewPresentMatch

A withNewPresentMatch(byte[] arg1,
                      int arg2)

withNewPresentMatch
```
A withNewPresentMatch(byte[] arg1)
```

withNewPresentMatch

A withNewPresentMatch(char[] arg1,
                      int arg2,
                      int arg3)

withNewPresentMatch

A withNewPresentMatch(byte[] arg1,
                      int arg2,
                      int arg3)

withNewPresentMatch

A withNewPresentMatch(byte[] arg1,
                      int arg2,
                      int arg3,
                      int arg4)

withNewPresentMatch
```
A withNewPresentMatch(String arg1)
```

getRangeMatch
```
String getRangeMatch()
```

withRangeMatch
```
A withRangeMatch(String rangeMatch)
```

hasRangeMatch
```
Boolean hasRangeMatch()
```

withNewRangeMatch

A withNewRangeMatch(StringBuilder arg1)

withNewRangeMatch

A withNewRangeMatch(int[] arg1,
                    int arg2,
                    int arg3)

withNewRangeMatch
```
A withNewRangeMatch(char[] arg1)
```

withNewRangeMatch

A withNewRangeMatch(StringBuffer arg1)

withNewRangeMatch

A withNewRangeMatch(byte[] arg1,
                    int arg2)

withNewRangeMatch
```
A withNewRangeMatch(byte[] arg1)
```

withNewRangeMatch

A withNewRangeMatch(char[] arg1,
                    int arg2,
                    int arg3)

withNewRangeMatch

A withNewRangeMatch(byte[] arg1,
                    int arg2,
                    int arg3)

withNewRangeMatch

A withNewRangeMatch(byte[] arg1,
                    int arg2,
                    int arg3,
                    int arg4)

withNewRangeMatch
```
A withNewRangeMatch(String arg1)
```

getRegexMatch
```
String getRegexMatch()
```

withRegexMatch
```
A withRegexMatch(String regexMatch)
```

hasRegexMatch
```
Boolean hasRegexMatch()
```

withNewRegexMatch

A withNewRegexMatch(StringBuilder arg1)

withNewRegexMatch

A withNewRegexMatch(int[] arg1,
                    int arg2,
                    int arg3)

withNewRegexMatch
```
A withNewRegexMatch(char[] arg1)
```

withNewRegexMatch

A withNewRegexMatch(StringBuffer arg1)

withNewRegexMatch

A withNewRegexMatch(byte[] arg1,
                    int arg2)

withNewRegexMatch
```
A withNewRegexMatch(byte[] arg1)
```

withNewRegexMatch

A withNewRegexMatch(char[] arg1,
                    int arg2,
                    int arg3)

withNewRegexMatch

A withNewRegexMatch(byte[] arg1,
                    int arg2,
                    int arg3)

withNewRegexMatch

A withNewRegexMatch(byte[] arg1,
                    int arg2,
                    int arg3,
                    int arg4)

withNewRegexMatch
```
A withNewRegexMatch(String arg1)
```

getSafeRegexMatch
```
String getSafeRegexMatch()
```

withSafeRegexMatch

A withSafeRegexMatch(String safeRegexMatch)

hasSafeRegexMatch
```
Boolean hasSafeRegexMatch()
```

withNewSafeRegexMatch

A withNewSafeRegexMatch(StringBuilder arg1)

withNewSafeRegexMatch

A withNewSafeRegexMatch(int[] arg1,
                        int arg2,
                        int arg3)

withNewSafeRegexMatch
```
A withNewSafeRegexMatch(char[] arg1)
```

withNewSafeRegexMatch

A withNewSafeRegexMatch(StringBuffer arg1)

withNewSafeRegexMatch

A withNewSafeRegexMatch(byte[] arg1,
                        int arg2)

withNewSafeRegexMatch
```
A withNewSafeRegexMatch(byte[] arg1)
```

withNewSafeRegexMatch

A withNewSafeRegexMatch(char[] arg1,
                        int arg2,
                        int arg3)

withNewSafeRegexMatch

A withNewSafeRegexMatch(byte[] arg1,
                        int arg2,
                        int arg3)

withNewSafeRegexMatch

A withNewSafeRegexMatch(byte[] arg1,
                        int arg2,
                        int arg3,
                        int arg4)

withNewSafeRegexMatch
```
A withNewSafeRegexMatch(String arg1)
```

getSuffixMatch
```
String getSuffixMatch()
```

withSuffixMatch
```
A withSuffixMatch(String suffixMatch)
```

hasSuffixMatch
```
Boolean hasSuffixMatch()
```

withNewSuffixMatch

A withNewSuffixMatch(StringBuilder arg1)

withNewSuffixMatch

A withNewSuffixMatch(int[] arg1,
                     int arg2,
                     int arg3)

withNewSuffixMatch
```
A withNewSuffixMatch(char[] arg1)
```

withNewSuffixMatch

A withNewSuffixMatch(StringBuffer arg1)

withNewSuffixMatch

A withNewSuffixMatch(byte[] arg1,
                     int arg2)

withNewSuffixMatch
```
A withNewSuffixMatch(byte[] arg1)
```

withNewSuffixMatch

A withNewSuffixMatch(char[] arg1,
                     int arg2,
                     int arg3)

withNewSuffixMatch

A withNewSuffixMatch(byte[] arg1,
                     int arg2,
                     int arg3)

withNewSuffixMatch

A withNewSuffixMatch(byte[] arg1,
                     int arg2,
                     int arg3,
                     int arg4)

withNewSuffixMatch
```
A withNewSuffixMatch(String arg1)
```

Interface MatcherFluent<A extends MatcherFluent<A>>

Method Summary

Method Detail

getExactMatch

withExactMatch

hasExactMatch

withNewExactMatch

withNewExactMatch

withNewExactMatch

withNewExactMatch

withNewExactMatch

withNewExactMatch

withNewExactMatch

withNewExactMatch

withNewExactMatch

withNewExactMatch

getInvertMatch

withInvertMatch

hasInvertMatch

withNewInvertMatch

withNewInvertMatch

withNewInvertMatch

withNewInvertMatch

withNewInvertMatch

withNewInvertMatch

withNewInvertMatch

withNewInvertMatch

withNewInvertMatch

withNewInvertMatch

getName

withName

hasName

withNewName

withNewName

withNewName

withNewName

withNewName

withNewName

withNewName

withNewName

withNewName

withNewName

getPrefixMatch

withPrefixMatch

hasPrefixMatch

withNewPrefixMatch

withNewPrefixMatch

withNewPrefixMatch

withNewPrefixMatch

withNewPrefixMatch

withNewPrefixMatch

withNewPrefixMatch

withNewPrefixMatch

withNewPrefixMatch

withNewPrefixMatch

getPresentMatch

withPresentMatch

hasPresentMatch

withNewPresentMatch

withNewPresentMatch

withNewPresentMatch

withNewPresentMatch

withNewPresentMatch

withNewPresentMatch

withNewPresentMatch

withNewPresentMatch

withNewPresentMatch

withNewPresentMatch

getRangeMatch

withRangeMatch

hasRangeMatch

withNewRangeMatch

withNewRangeMatch

withNewRangeMatch

withNewRangeMatch

withNewRangeMatch

withNewRangeMatch

withNewRangeMatch

withNewRangeMatch

withNewRangeMatch