skyem123 / stringmatcher1 Goto Github PK

Can we get a switch matcher? It's a set of key-value pairs (aka a HashMap (but not necessarily)) that is much faster than alternations (O(1) vs O(n)).

First you need a pattern. This pattern will be used to lookup a pattern in the map. After matching the pattern, and looking up the result in the map, there are 2 possible outcomes:

• The value is null, or the key doesn't exist.
  • Check for a default case, which is set by using setCase(null, pattern). This has 2 possible outcomes:
    • If there is no default case, the match fails.
    • If there is a default case, we attempt to match it.
• The value is not null. Attempt to match it.

Constructing and using switch matchers could be done as in switch(pattern).setCase(string, pattern).setCase(string, pattern).setCase(null, pattern).

Removing cases could be done with setCase(string, null).

Possible ideas:

• Use a more efficient regex library
• Avoid using regex for simple matchers like the EverythingMatcher

• might want to rename package to uk.co.skyem.libraries.stringMatcher1
• Issue #12 (API Documentation)
• Issue #10 (CI & Code coverage)
• Issue #7 (If I ever want this in maven central, I only can rely on maven central)
• Issue #4 would be useful! Slow stuff is not nice to use.

JetBrains/kotlin@15d6949 removes the need for my work-around code, so I should remove it when it's part of the main release.

This will be useful for testing and also be a good idea overall.

This is very important for a library, and it will also be good to have tutorials in this repo.

_Note that this issue will not be closed, as it is an important reminder to new code written_

This is a separate issue, because it is not essential.

Issue #15 seems like an interesting way to combine multiple matchers, but other ways of linking matchers together will also be useful.

Combining matchers with methods on the Matcher class

(Maybe the methods should use varargs to reduce the number of ( and ) needed.)

.and(Matcher)

This will do an and operation between the two matchers.
For a very simple example, matchAll().and(match("test")).useOn("this is a test") should only have one match result, which would be 10 4 test. This would also work reversed, for example match("test").and(matchAll()).useOn("this is a test") would have exactly the same result.

A more complex example of the .and(Matcher) system would be startsWith(match("this")).and(endsWith(match("hello"))).useOn("this is a test, hello world!") will have a single match result of 10 21 test, hello.

.or(Matcher)

This will do an or operation between the two matchers. For example, startsWith(match("this")).or(endsWith(match("hello"))).useOn("this is a test, hello world!") will have a single match result of 0 28 this is a test, hello world!
For a more complex example, match("test").or(match("hello")).useOn("this is a test, hello world!") will have two match results, 10 14 test and 16 21 hello.