org.eclipse.jdt.internal.core.search.matching.AndPattern Maven / Gradle / Ivy
The newest version!
/*******************************************************************************
* Copyright (c) 2000, 2008 IBM Corporation and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jdt.internal.core.search.matching;
import java.util.stream.Stream;
import org.eclipse.jdt.core.search.IParallelizable;
import org.eclipse.jdt.core.search.SearchPattern;
public class AndPattern extends IntersectingPattern {
protected SearchPattern[] patterns;
int current;
private static int combinedMatchRule(int matchRule, int matchRule2) {
int combined = matchRule & matchRule2;
int compatibility = combined & MATCH_COMPATIBILITY_MASK;
if (compatibility == 0) {
if ((matchRule & MATCH_COMPATIBILITY_MASK) == R_FULL_MATCH) {
compatibility = matchRule2;
} else if ((matchRule2 & MATCH_COMPATIBILITY_MASK) == R_FULL_MATCH) {
compatibility = matchRule;
} else {
compatibility = Math.min(matchRule & MATCH_COMPATIBILITY_MASK, matchRule2 & MATCH_COMPATIBILITY_MASK);
}
}
return (combined & (R_EXACT_MATCH | R_PREFIX_MATCH | R_PATTERN_MATCH | R_REGEXP_MATCH))
| (combined & R_CASE_SENSITIVE)
| compatibility
| (combined & (R_CAMELCASE_MATCH | R_CAMELCASE_SAME_PART_COUNT_MATCH));
}
public AndPattern(SearchPattern leftPattern, SearchPattern rightPattern) {
super(AND_PATTERN, combinedMatchRule(leftPattern.getMatchRule(), rightPattern.getMatchRule()));
this.mustResolve = leftPattern.mustResolve || rightPattern.mustResolve;
SearchPattern[] leftPatterns = leftPattern instanceof AndPattern ? ((AndPattern) leftPattern).patterns : null;
SearchPattern[] rightPatterns = rightPattern instanceof AndPattern ? ((AndPattern) rightPattern).patterns : null;
int leftSize = leftPatterns == null ? 1 : leftPatterns.length;
int rightSize = rightPatterns == null ? 1 : rightPatterns.length;
this.patterns = new SearchPattern[leftSize + rightSize];
if (leftPatterns == null)
this.patterns[0] = leftPattern;
else
System.arraycopy(leftPatterns, 0, this.patterns, 0, leftSize);
if (rightPatterns == null)
this.patterns[leftSize] = rightPattern;
else
System.arraycopy(rightPatterns, 0, this.patterns, leftSize, rightSize);
// Store erasure match
this.matchCompatibility = getMatchRule() & MATCH_COMPATIBILITY_MASK;
this.current = 0;
}
@Override
public SearchPattern currentPattern() {
return this.patterns[this.current++];
}
@Override
protected boolean hasNextQuery() {
return this.current < (this.patterns.length-1);
}
@Override
protected void resetQuery() {
this.current = 0;
}
@Override
public boolean isParallelSearchSupported() {
return Stream.of(this.patterns).allMatch(IParallelizable::isParallelSearchSupported);
}
@Override
public SearchPattern clone() throws CloneNotSupportedException {
AndPattern pattern = (AndPattern) super.clone();
pattern.patterns = this.patterns.clone();
for (int i = 0; i < this.patterns.length; i++) {
pattern.patterns[i] = this.patterns[i].clone();
}
return pattern;
}
}