in src/main/software/amazon/event/ruler/ByteMachine.java [1053:1190]
private NameState findRangePattern(Range range) {
Set<NameState> nextNameStates = new HashSet<>();
NameState nextNameState = null;
ByteTransition forkTrans = startState;
int forkOffset = 0;
// bypass common prefix of range's bottom and top patterns
while (range.bottom[forkOffset] == range.top[forkOffset]) {
forkTrans = findNextByteStateForRangePattern(forkTrans, range.bottom[forkOffset++]);
if (forkTrans == null) {
return null;
}
}
// fill in matches in the fork state
for (byte bb : Range.digitSequence(range.bottom[forkOffset], range.top[forkOffset], false, false, range.isCIDR)) {
nextNameState = findMatchForRangePattern(bb, forkTrans, range);
if (nextNameState == null) {
return null;
}
nextNameStates.add(nextNameState);
}
// process all the transitions on the bottom range bytes
ByteTransition trans = forkTrans;
int lastMatchOffset = forkOffset;
for (int offsetB = forkOffset + 1; offsetB < (range.bottom.length - 1); offsetB++) {
byte b = range.bottom[offsetB];
if (b < range.maxDigit()) {
while (lastMatchOffset < offsetB) {
trans = findNextByteStateForRangePattern(trans, range.bottom[lastMatchOffset++]);
if (trans == null) {
return null;
}
}
assert lastMatchOffset == offsetB : "lastMatchOffset == offsetB";
for (byte bb : Range.digitSequence(b, range.maxDigit(), false, true, range.isCIDR)) {
nextNameState = findMatchForRangePattern(bb, trans, range);
if (nextNameState == null) {
return null;
}
nextNameStates.add(nextNameState);
}
}
}
// now for last "bottom" digit
final byte lastBottom = range.bottom[range.bottom.length - 1];
final byte lastTop = range.top[range.top.length - 1];
if ((lastBottom < range.maxDigit()) || !range.openBottom) {
while (lastMatchOffset < range.bottom.length - 1) {
trans = findNextByteStateForRangePattern(trans, range.bottom[lastMatchOffset++]);
if (trans == null) {
return null;
}
}
assert lastMatchOffset == (range.bottom.length - 1) : "lastMatchOffset == (range.bottom.length - 1)";
if (!range.openBottom) {
nextNameState = findMatchForRangePattern(lastBottom, trans, range);
if (nextNameState == null) {
return null;
}
nextNameStates.add(nextNameState);
}
// unless the last digit is also at the fork position, fill in the extra matches due to
// the strictly-less-than condition (see discussion above)
if (forkOffset < (range.bottom.length - 1)) {
for (byte bb : Range.digitSequence(lastBottom, range.maxDigit(), false, true, range.isCIDR)) {
nextNameState = findMatchForRangePattern(bb, trans, range);
if (nextNameState == null) {
return null;
}
nextNameStates.add(nextNameState);
}
}
}
// now process transitions along the top range bytes
trans = forkTrans;
lastMatchOffset = forkOffset;
for (int offsetT = forkOffset + 1; offsetT < (range.top.length - 1); offsetT++) {
byte b = range.top[offsetT];
if (b > range.minDigit()) {
while (lastMatchOffset < offsetT) {
trans = findNextByteStateForRangePattern(trans, range.top[lastMatchOffset++]);
if (trans == null) {
return null;
}
}
assert lastMatchOffset == offsetT : "lastMatchOffset == offsetT";
for (byte bb : Range.digitSequence(range.minDigit(), range.top[offsetT], true, false, range.isCIDR)) {
nextNameState = findMatchForRangePattern(bb, trans, range);
if (nextNameState == null) {
return null;
}
nextNameStates.add(nextNameState);
}
}
}
// now for last "top" digit
if ((lastTop > range.minDigit()) || !range.openTop) {
while (lastMatchOffset < range.top.length - 1) {
trans = findNextByteStateForRangePattern(trans, range.top[lastMatchOffset++]);
if (trans == null) {
return null;
}
}
assert lastMatchOffset == (range.top.length - 1) : "lastMatchOffset == (range.top.length - 1)";
if (!range.openTop) {
nextNameState = findMatchForRangePattern(lastTop, trans, range);
if (nextNameState == null) {
return null;
}
nextNameStates.add(nextNameState);
}
// unless the last digit is also at the fork position, fill in the extra matches due to
// the strictly-less-than condition (see discussion above)
if (forkOffset < (range.top.length - 1)) {
for (byte bb : Range.digitSequence(range.minDigit(), lastTop, true, false, range.isCIDR)) {
nextNameState = findMatchForRangePattern(bb, trans, range);
if (nextNameState == null) {
return null;
}
nextNameStates.add(nextNameState);
}
}
}
// There must only have one nextNameState object returned by this range pattern refer to
// addRangePattern() where only one nextNameState is used by one pattern.
assert nextNameStates.size() == 1 : "nextNameStates.size() == 1";
return nextNameState;
}