/*
 * Copyright (C) 2009, Google Inc.
 * Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org> and others
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Distribution License v. 1.0 which is available at
 * https://www.eclipse.org/org/documents/edl-v10.php.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

package org.eclipse.jgit.util;

import org.eclipse.jgit.internal.JGitText;
import org.eclipse.jgit.lib.Constants;

Searches text using only substring search.

Instances are thread-safe. Multiple concurrent threads may perform matches on different character sequences at the same time.

/** * Searches text using only substring search. * <p> * Instances are thread-safe. Multiple concurrent threads may perform matches on * different character sequences at the same time. */
public class RawSubStringPattern { private final String needleString; private final byte[] needle;
Construct a new substring pattern.
Params:
  • patternText – text to locate. This should be a literal string, as no meta-characters are supported by this implementation. The string may not be the empty string.
/** * Construct a new substring pattern. * * @param patternText * text to locate. This should be a literal string, as no * meta-characters are supported by this implementation. The * string may not be the empty string. */
public RawSubStringPattern(String patternText) { if (patternText.length() == 0) throw new IllegalArgumentException(JGitText.get().cannotMatchOnEmptyString); needleString = patternText; final byte[] b = Constants.encode(patternText); needle = new byte[b.length]; for (int i = 0; i < b.length; i++) needle[i] = lc(b[i]); }
Match a character sequence against this pattern.
Params:
  • rcs – the sequence to match. Must not be null but the length of the sequence is permitted to be 0.
Returns:offset within rcs of the first occurrence of this pattern; -1 if this pattern does not appear at any position of rcs.
/** * Match a character sequence against this pattern. * * @param rcs * the sequence to match. Must not be null but the length of the * sequence is permitted to be 0. * @return offset within <code>rcs</code> of the first occurrence of this * pattern; -1 if this pattern does not appear at any position of * <code>rcs</code>. */
public int match(RawCharSequence rcs) { final int needleLen = needle.length; final byte first = needle[0]; final byte[] text = rcs.buffer; int matchPos = rcs.startPtr; final int maxPos = rcs.endPtr - needleLen; OUTER: for (; matchPos <= maxPos; matchPos++) { if (neq(first, text[matchPos])) { while (++matchPos <= maxPos && neq(first, text[matchPos])) { /* skip */ } if (matchPos > maxPos) return -1; } int si = matchPos + 1; for (int j = 1; j < needleLen; j++, si++) { if (neq(needle[j], text[si])) continue OUTER; } return matchPos; } return -1; } private static final boolean neq(byte a, byte b) { return a != b && a != lc(b); } private static final byte lc(byte q) { return (byte) StringUtils.toLowerCase((char) (q & 0xff)); }
Get the literal pattern string this instance searches for.
Returns:the pattern string given to our constructor.
/** * Get the literal pattern string this instance searches for. * * @return the pattern string given to our constructor. */
public String pattern() { return needleString; }
{@inheritDoc}
/** {@inheritDoc} */
@Override public String toString() { return pattern(); } }