/** * Replace all characters in the input string with the replacement character. */ public String replaceNonMembers(String input, char replacement) { if (!contains(replacement)) { throw new IllegalArgumentException(replacement + " is not a member of " + pattern); } return containsAll(input) ? input : replaceNonMembersImpl(input, replacement); }
private String fixKey(String k) { return set.replaceNonMembers(k, '_'); }
@SuppressWarnings("PMD") private AsciiSet charClass() { AsciiSet tmp; AsciiSet set = AsciiSet.none(); boolean rangeStart = false; boolean invert = peek() == '^'; if (invert) { advance(); set = AsciiSet.all(); set = update(set, AsciiSet.fromPattern(Character.toString(c)), invert); switch (c) { case '[': set = set.union(charClass()); rangeStart = false; break; if (peek() == '[') { advance(); set = set.intersection(charClass()); } else if (peek() != ']') { set = set.intersection(charClass()); --current; set = update(set, AsciiSet.fromPattern(Character.toString(c)), invert); c = advance(); rangeStart = true; set = update(set, AsciiSet.fromPattern(Character.toString(c)), invert);
@Test public void replaceAllOk() { AsciiSet s = AsciiSet.fromPattern("*0-2A-C"); Assertions.assertEquals("012ABC", s.replaceNonMembers("012ABC", '*')); }
@Test public void rangeContains() { AsciiSet s = AsciiSet.fromPattern("A-C"); Assertions.assertTrue(s.contains('A')); Assertions.assertFalse(s.contains('D')); Assertions.assertFalse(s.contains('-')); }
@Test public void empty() { AsciiSet s = AsciiSet.fromPattern(""); Assertions.assertEquals("", s.toString()); }
@Test public void multiRangeContains() { AsciiSet s = AsciiSet.fromPattern("0-2A-C"); Assertions.assertTrue(s.containsAll("012ABC")); Assertions.assertFalse(s.containsAll("3")); Assertions.assertFalse(s.contains('-')); }
@Test public void rangeContainsAll() { AsciiSet s = AsciiSet.fromPattern("A-C"); Assertions.assertTrue(s.containsAll("BCAAABCBCBB")); Assertions.assertFalse(s.containsAll("BCAAABCBCBBD")); }
/** Create a new instance. */ public AtlasRegistry(Clock clock, AtlasConfig config) { super(clock, config); this.config = config; this.stepClock = new StepClock(clock, config.step().toMillis()); this.step = config.step(); this.stepMillis = step.toMillis(); this.meterTTL = config.meterTTL().toMillis(); this.uri = URI.create(config.uri()); this.configRefreshFrequency = config.configRefreshFrequency(); this.evalUri = URI.create(config.evalUri()); this.connectTimeout = (int) config.connectTimeout().toMillis(); this.readTimeout = (int) config.readTimeout().toMillis(); this.batchSize = config.batchSize(); this.numThreads = config.numThreads(); this.commonTags = new TreeMap<>(config.commonTags()); this.charset = AsciiSet.fromPattern(config.validTagCharacters()); this.overrides = config.validTagValueCharacters() .keySet().stream() .collect(Collectors.toMap(k -> k, AsciiSet::fromPattern)); SimpleModule module = new SimpleModule() .addSerializer(Measurement.class, new MeasurementSerializer(charset, overrides)); this.jsonMapper = new ObjectMapper(new JsonFactory()).registerModule(module); this.smileMapper = new ObjectMapper(new SmileFactory()).registerModule(module); this.client = HttpClient.create(this); this.subManager = new SubscriptionManager(jsonMapper, client, clock, config); }
/** * Returns a new set that will match characters iff they are included this set and not in the * set that is provided. */ public AsciiSet diff(AsciiSet set) { final boolean[] diffMembers = new boolean[128]; for (int i = 0; i < diffMembers.length; ++i) { diffMembers[i] = members[i] && !set.members[i]; } return new AsciiSet(diffMembers); }
@Test public void convertEmptyCharClassToFalse() { Matcher input = new CharClassMatcher(AsciiSet.none()); Matcher expected = FalseMatcher.INSTANCE; Assertions.assertEquals(expected, Optimizer.convertEmptyCharClassToFalse(input)); }
/** * If a character class has a single value, then just match that value ({@code "[a]" => "a"}). * This allows other optimizations to merge the value into adjacent matchers to get a larger * prefix or indexOf check. */ static Matcher convertSingleCharClassToSeq(Matcher matcher) { if (matcher instanceof CharClassMatcher) { Optional<Character> opt = matcher.<CharClassMatcher>as().set().character(); if (opt.isPresent()) { return new CharSeqMatcher(opt.get()); } } return matcher; }
/** * Converts the members array to a pattern string. Used to provide a user friendly toString * implementation for the set. */ private static String toPattern(boolean[] members) { StringBuilder buf = new StringBuilder(); if (members['-']) { buf.append('-'); } boolean previous = false; char s = 0; for (int i = 0; i < members.length; ++i) { if (members[i] && !previous) { s = (char) i; } else if (!members[i] && previous) { final char e = (char) (i - 1); append(buf, s, e); } previous = members[i]; } if (previous) { final char e = (char) (members.length - 1); append(buf, s, e); } return buf.toString(); }
@SuppressWarnings("PMD") private AsciiSet charClass() { AsciiSet tmp; AsciiSet set = AsciiSet.none(); boolean rangeStart = false; boolean invert = peek() == '^'; if (invert) { advance(); set = AsciiSet.all(); set = update(set, AsciiSet.fromPattern(Character.toString(c)), invert); switch (c) { case '[': set = set.union(charClass()); rangeStart = false; break; if (peek() == '[') { advance(); set = set.intersection(charClass()); } else if (peek() != ']') { set = set.intersection(charClass()); --current; set = update(set, AsciiSet.fromPattern(Character.toString(c)), invert); c = advance(); rangeStart = true; set = update(set, AsciiSet.fromPattern(Character.toString(c)), invert);
@Test public void replace() { AsciiSet s = AsciiSet.fromPattern("*0-2A-C"); Assertions.assertEquals("012*ABC*", s.replaceNonMembers("0123ABCD", '*')); }
@Test public void dashEnd() { AsciiSet s = AsciiSet.fromPattern("A-C-"); Assertions.assertTrue(s.contains('-')); Assertions.assertTrue(s.contains('B')); Assertions.assertFalse(s.contains('D')); }
@Test public void rangeToString() { AsciiSet s1 = AsciiSet.fromPattern("A-C"); AsciiSet s2 = AsciiSet.fromPattern("ABC"); Assertions.assertEquals("A-C", s2.toString()); Assertions.assertEquals(s1, s2); }