core/plugins/org.eclipse.dltk.core/search/org/eclipse/dltk/internal/core/search/matching/MatchingNodeSet.java - dltk/org.eclipse.dltk.core - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2017 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  *******************************************************************************/
 package org.eclipse.dltk.internal.core.search.matching;

 import java.util.ArrayList;

 import org.eclipse.dltk.ast.ASTNode;
 import org.eclipse.dltk.compiler.util.HashtableOfLong;
 import org.eclipse.dltk.compiler.util.SimpleLookupTable;
 import org.eclipse.dltk.compiler.util.SimpleSet;
 import org.eclipse.dltk.core.DLTKCore;
 import org.eclipse.dltk.core.search.SearchMatch;
 import org.eclipse.dltk.core.search.SearchPattern;
 import org.eclipse.dltk.core.search.matching.PatternLocator;
 import org.eclipse.dltk.internal.core.util.Util;

 /**
  * A set of matches and possible matches, which need to be resolved.
  */
 public class MatchingNodeSet {
 	/**
 	 * Map of matching ast nodes that don't need to be resolved to their
 	 * accuracy level. Each node is removed as it is reported.
 	 */
 	public SimpleLookupTable matchingNodes = new SimpleLookupTable(3); // node
 	// ->
 	// accuracy
 	private HashtableOfLong matchingNodesKeys = new HashtableOfLong(3); // sourceRange
 	// ->
 	// node
 	static final Integer EXACT_MATCH = Integer.valueOf(SearchMatch.A_ACCURATE);
 	static final Integer POTENTIAL_MATCH = Integer.valueOf(SearchMatch.A_INACCURATE);
 	static final Integer ERASURE_MATCH = Integer.valueOf(SearchPattern.R_ERASURE_MATCH);
 	/**
 	 * Set of possible matching ast nodes. They need to be resolved to determine
 	 * if they really match the search pattern.
 	 */
 	public SimpleSet possibleMatchingNodesSet = new SimpleSet(7);
 	private HashtableOfLong possibleMatchingNodesKeys = new HashtableOfLong(7);

 	public MatchingNodeSet() {
 		super();
 	}

 	public int addMatch(ASTNode node, int matchLevel) {
 		switch (matchLevel & PatternLocator.NODE_SET_MASK) {
 		case PatternLocator.INACCURATE_MATCH:
 			addTrustedMatch(node, POTENTIAL_MATCH);
 			break;
 		case PatternLocator.POSSIBLE_MATCH:
 			addPossibleMatch(node);
 			break;
 		case PatternLocator.ERASURE_MATCH:
 			addTrustedMatch(node, ERASURE_MATCH);
 			break;
 		case PatternLocator.ACCURATE_MATCH:
 			addTrustedMatch(node, EXACT_MATCH);
 		}
 		return matchLevel;
 	}

 	public void addPossibleMatch(ASTNode node) {
 		// remove existing node at same position from set
 		// (case of recovery that created the same node several time
 		// see http://bugs.eclipse.org/bugs/show_bug.cgi?id=29366)
 		long key = computeNodeKey(node);
 		ASTNode existing = (ASTNode) this.possibleMatchingNodesKeys.get(key);
 		if (existing != null && existing.getClass().equals(node.getClass()))
 			this.possibleMatchingNodesSet.remove(existing);
 		// add node to set
 		this.possibleMatchingNodesSet.add(node);
 		this.possibleMatchingNodesKeys.put(key, node);
 	}

 	public void addTrustedMatch(ASTNode node, boolean isExact) {
 		addTrustedMatch(node, isExact ? EXACT_MATCH : POTENTIAL_MATCH);
 	}

 	void addTrustedMatch(ASTNode node, Integer level) {
 		// remove existing node at same position from set
 		// (case of recovery that created the same node several time
 		// see http://bugs.eclipse.org/bugs/show_bug.cgi?id=29366)
 		long key = computeNodeKey(node);
 		ASTNode existing = (ASTNode) this.matchingNodesKeys.get(key);
 		if (existing != null && existing.getClass().equals(node.getClass()))
 			this.matchingNodes.removeKey(existing);
 		// map node to its accuracy level
 		this.matchingNodes.put(node, level);
 		this.matchingNodesKeys.put(key, node);
 	}

 	protected boolean hasPossibleNodes(int start, int end) {
 		Object[] nodes = this.possibleMatchingNodesSet.values;
 		for (int i = 0, l = nodes.length; i < l; i++) {
 			ASTNode node = (ASTNode) nodes[i];
 			if (node != null && start <= node.sourceStart()
 					&& node.sourceEnd() <= end)
 				return true;
 		}
 		nodes = this.matchingNodes.keyTable;
 		for (int i = 0, l = nodes.length; i < l; i++) {
 			ASTNode node = (ASTNode) nodes[i];
 			if (node != null && start <= node.sourceStart()
 					&& node.sourceEnd() <= end)
 				return true;
 		}
 		return false;
 	}

 	/**
 	 * Returns the matching nodes that are in the given range in the source
 	 * order.
 	 */
 	public ASTNode[] matchingNodes(int start, int end) {
 		ArrayList nodes = null;
 		Object[] keyTable = this.matchingNodes.keyTable;
 		for (int i = 0, l = keyTable.length; i < l; i++) {
 			ASTNode node = (ASTNode) keyTable[i];
 			if (node != null && start <= node.sourceStart()
 					&& node.sourceEnd() <= end) {
 				if (nodes == null)
 					nodes = new ArrayList();
 				nodes.add(node);
 			}
 		}
 		if (nodes == null)
 			return null;
 		ASTNode[] result = new ASTNode[nodes.size()];
 		nodes.toArray(result);
 		// sort nodes by source starts
 		Util.Comparer comparer = (o1, o2) -> ((ASTNode) o1).sourceStart()
 				- ((ASTNode) o2).sourceStart();
 		Util.sort(result, comparer);
 		return result;
 	}

 	public Object removePossibleMatch(ASTNode node) {
 		long key = computeNodeKey(node);
 		ASTNode existing = (ASTNode) this.possibleMatchingNodesKeys.get(key);
 		if (existing == null)
 			return null;
 		this.possibleMatchingNodesKeys.put(key, null);
 		return this.possibleMatchingNodesSet.remove(node);
 	}

 	private long computeNodeKey(ASTNode node) {
 		return ((((long) node.sourceStart()) << 32) + node.sourceEnd());
 	}

 	public Object removeTrustedMatch(ASTNode node) {
 		long key = computeNodeKey(node);
 		ASTNode existing = (ASTNode) this.matchingNodesKeys.get(key);
 		if (existing == null)
 			return null;
 		this.matchingNodesKeys.put(key, null);
 		return this.matchingNodes.removeKey(node);
 	}

 	@Override
 	public String toString() {
 		// TODO (jerome) should show both tables
 		StringBuffer result = new StringBuffer();
 		result.append("Exact matches:"); //$NON-NLS-1$
 		Object[] keyTable = this.matchingNodes.keyTable;
 		Object[] valueTable = this.matchingNodes.valueTable;
 		for (int i = 0, l = keyTable.length; i < l; i++) {
 			ASTNode node = (ASTNode) keyTable[i];
 			if (node == null)
 				continue;
 			result.append("\n\t"); //$NON-NLS-1$
 			switch (((Integer) valueTable[i]).intValue()) {
 			case SearchMatch.A_ACCURATE:
 				result.append("ACCURATE_MATCH: "); //$NON-NLS-1$
 				break;
 			case SearchMatch.A_INACCURATE:
 				result.append("INACCURATE_MATCH: "); //$NON-NLS-1$
 				break;
 			case SearchPattern.R_ERASURE_MATCH:
 				result.append("ERASURE_MATCH: "); //$NON-NLS-1$
 				break;
 			}
 			// node.print(0, result);
 			if (DLTKCore.DEBUG) {
 				System.err.println("TODO: Add node print..."); //$NON-NLS-1$
 			}
 		}
 		result.append("\nPossible matches:"); //$NON-NLS-1$
 		Object[] nodes = this.possibleMatchingNodesSet.values;
 		for (int i = 0, l = nodes.length; i < l; i++) {
 			ASTNode node = (ASTNode) nodes[i];
 			if (node == null)
 				continue;
 			result.append("\nPOSSIBLE_MATCH: "); //$NON-NLS-1$
 			// node.print(0, result);
 			if (DLTKCore.DEBUG) {
 				System.err.println("TODO: Add node print..."); //$NON-NLS-1$
 			}
 		}
 		return result.toString();
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2017 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	*******************************************************************************/
	package org.eclipse.dltk.internal.core.search.matching;

	import java.util.ArrayList;

	import org.eclipse.dltk.ast.ASTNode;
	import org.eclipse.dltk.compiler.util.HashtableOfLong;
	import org.eclipse.dltk.compiler.util.SimpleLookupTable;
	import org.eclipse.dltk.compiler.util.SimpleSet;
	import org.eclipse.dltk.core.DLTKCore;
	import org.eclipse.dltk.core.search.SearchMatch;
	import org.eclipse.dltk.core.search.SearchPattern;
	import org.eclipse.dltk.core.search.matching.PatternLocator;
	import org.eclipse.dltk.internal.core.util.Util;

	/**
	* A set of matches and possible matches, which need to be resolved.
	*/
	public class MatchingNodeSet {
	/**
	* Map of matching ast nodes that don't need to be resolved to their
	* accuracy level. Each node is removed as it is reported.
	*/
	public SimpleLookupTable matchingNodes = new SimpleLookupTable(3); // node
	// ->
	// accuracy
	private HashtableOfLong matchingNodesKeys = new HashtableOfLong(3); // sourceRange
	// ->
	// node
	static final Integer EXACT_MATCH = Integer.valueOf(SearchMatch.A_ACCURATE);
	static final Integer POTENTIAL_MATCH = Integer.valueOf(SearchMatch.A_INACCURATE);
	static final Integer ERASURE_MATCH = Integer.valueOf(SearchPattern.R_ERASURE_MATCH);
	/**
	* Set of possible matching ast nodes. They need to be resolved to determine
	* if they really match the search pattern.
	*/
	public SimpleSet possibleMatchingNodesSet = new SimpleSet(7);
	private HashtableOfLong possibleMatchingNodesKeys = new HashtableOfLong(7);

	public MatchingNodeSet() {
	super();
	}

	public int addMatch(ASTNode node, int matchLevel) {
	switch (matchLevel & PatternLocator.NODE_SET_MASK) {
	case PatternLocator.INACCURATE_MATCH:
	addTrustedMatch(node, POTENTIAL_MATCH);
	break;
	case PatternLocator.POSSIBLE_MATCH:
	addPossibleMatch(node);
	break;
	case PatternLocator.ERASURE_MATCH:
	addTrustedMatch(node, ERASURE_MATCH);
	break;
	case PatternLocator.ACCURATE_MATCH:
	addTrustedMatch(node, EXACT_MATCH);
	}
	return matchLevel;
	}

	public void addPossibleMatch(ASTNode node) {
	// remove existing node at same position from set
	// (case of recovery that created the same node several time
	// see http://bugs.eclipse.org/bugs/show_bug.cgi?id=29366)
	long key = computeNodeKey(node);
	ASTNode existing = (ASTNode) this.possibleMatchingNodesKeys.get(key);
	if (existing != null && existing.getClass().equals(node.getClass()))
	this.possibleMatchingNodesSet.remove(existing);
	// add node to set
	this.possibleMatchingNodesSet.add(node);
	this.possibleMatchingNodesKeys.put(key, node);
	}

	public void addTrustedMatch(ASTNode node, boolean isExact) {
	addTrustedMatch(node, isExact ? EXACT_MATCH : POTENTIAL_MATCH);
	}

	void addTrustedMatch(ASTNode node, Integer level) {
	// remove existing node at same position from set
	// (case of recovery that created the same node several time
	// see http://bugs.eclipse.org/bugs/show_bug.cgi?id=29366)
	long key = computeNodeKey(node);
	ASTNode existing = (ASTNode) this.matchingNodesKeys.get(key);
	if (existing != null && existing.getClass().equals(node.getClass()))
	this.matchingNodes.removeKey(existing);
	// map node to its accuracy level
	this.matchingNodes.put(node, level);
	this.matchingNodesKeys.put(key, node);
	}

	protected boolean hasPossibleNodes(int start, int end) {
	Object[] nodes = this.possibleMatchingNodesSet.values;
	for (int i = 0, l = nodes.length; i < l; i++) {
	ASTNode node = (ASTNode) nodes[i];
	if (node != null && start <= node.sourceStart()
	&& node.sourceEnd() <= end)
	return true;
	}
	nodes = this.matchingNodes.keyTable;
	for (int i = 0, l = nodes.length; i < l; i++) {
	ASTNode node = (ASTNode) nodes[i];
	if (node != null && start <= node.sourceStart()
	&& node.sourceEnd() <= end)
	return true;
	}
	return false;
	}

	/**
	* Returns the matching nodes that are in the given range in the source
	* order.
	*/
	public ASTNode[] matchingNodes(int start, int end) {
	ArrayList nodes = null;
	Object[] keyTable = this.matchingNodes.keyTable;
	for (int i = 0, l = keyTable.length; i < l; i++) {
	ASTNode node = (ASTNode) keyTable[i];
	if (node != null && start <= node.sourceStart()
	&& node.sourceEnd() <= end) {
	if (nodes == null)
	nodes = new ArrayList();
	nodes.add(node);
	}
	}
	if (nodes == null)
	return null;
	ASTNode[] result = new ASTNode[nodes.size()];
	nodes.toArray(result);
	// sort nodes by source starts
	Util.Comparer comparer = (o1, o2) -> ((ASTNode) o1).sourceStart()
	- ((ASTNode) o2).sourceStart();
	Util.sort(result, comparer);
	return result;
	}

	public Object removePossibleMatch(ASTNode node) {
	long key = computeNodeKey(node);
	ASTNode existing = (ASTNode) this.possibleMatchingNodesKeys.get(key);
	if (existing == null)
	return null;
	this.possibleMatchingNodesKeys.put(key, null);
	return this.possibleMatchingNodesSet.remove(node);
	}

	private long computeNodeKey(ASTNode node) {
	return ((((long) node.sourceStart()) << 32) + node.sourceEnd());
	}

	public Object removeTrustedMatch(ASTNode node) {
	long key = computeNodeKey(node);
	ASTNode existing = (ASTNode) this.matchingNodesKeys.get(key);
	if (existing == null)
	return null;
	this.matchingNodesKeys.put(key, null);
	return this.matchingNodes.removeKey(node);
	}

	@Override
	public String toString() {
	// TODO (jerome) should show both tables
	StringBuffer result = new StringBuffer();
	result.append("Exact matches:"); //$NON-NLS-1$
	Object[] keyTable = this.matchingNodes.keyTable;
	Object[] valueTable = this.matchingNodes.valueTable;
	for (int i = 0, l = keyTable.length; i < l; i++) {
	ASTNode node = (ASTNode) keyTable[i];
	if (node == null)
	continue;
	result.append("\n\t"); //$NON-NLS-1$
	switch (((Integer) valueTable[i]).intValue()) {
	case SearchMatch.A_ACCURATE:
	result.append("ACCURATE_MATCH: "); //$NON-NLS-1$
	break;
	case SearchMatch.A_INACCURATE:
	result.append("INACCURATE_MATCH: "); //$NON-NLS-1$
	break;
	case SearchPattern.R_ERASURE_MATCH:
	result.append("ERASURE_MATCH: "); //$NON-NLS-1$
	break;
	}
	// node.print(0, result);
	if (DLTKCore.DEBUG) {
	System.err.println("TODO: Add node print..."); //$NON-NLS-1$
	}
	}
	result.append("\nPossible matches:"); //$NON-NLS-1$
	Object[] nodes = this.possibleMatchingNodesSet.values;
	for (int i = 0, l = nodes.length; i < l; i++) {
	ASTNode node = (ASTNode) nodes[i];
	if (node == null)
	continue;
	result.append("\nPOSSIBLE_MATCH: "); //$NON-NLS-1$
	// node.print(0, result);
	if (DLTKCore.DEBUG) {
	System.err.println("TODO: Add node print..."); //$NON-NLS-1$
	}
	}
	return result.toString();
	}
	}