Copyright (c) 2000, 2013 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
/*******************************************************************************
 * Copyright (c) 2000, 2013 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.core.expressions;

import java.util.ArrayList;
import java.util.List;

A status object describing information about an expression tree.
This information can for example be used to decide whether an
expression tree has to be reevaluated if the value of some
variables changes.

This class is not intended to be extended by clients.

Since:
3.2
@noextend
This class is not intended to be subclassed by clients./**
 * A status object describing information about an expression tree.
 * This information can for example be used to decide whether an
 * expression tree has to be reevaluated if the value of some
 * variables changes.
 * <p>
 * This class is not intended to be extended by clients.
 * </p>
 *
 * @since 3.2
 *
 * @noextend This class is not intended to be subclassed by clients.
 */
public class ExpressionInfo {

	private boolean fHasDefaultVariableAccess;
	private boolean fHasSystemPropertyAccess;

	// Although we are using this as sets we use lists since
	// they are faster for smaller numbers of elements
	private List<String> fAccessedVariableNames;
	private List<Class<?>> fMisbehavingExpressionTypes;
	private List<String> fAccessedPropertyNames;

	
Returns true if the default variable is accessed
by the expression tree.
Returns:
whether the default variable is accessed or not/**
	 * Returns <code>true</code> if the default variable is accessed
	 * by the expression tree.
	 *
	 * @return whether the default variable is accessed or not
	 */
	public boolean hasDefaultVariableAccess() {
		return fHasDefaultVariableAccess;
	}

	
Marks the default variable as accessed.
/**
	 * Marks the default variable as accessed.
	 */
	public void markDefaultVariableAccessed() {
		fHasDefaultVariableAccess= true;
	}

	
Returns true if the system property is accessed
by the expression tree.
Returns:
whether the system property is accessed or not/**
	 * Returns <code>true</code> if the system property is accessed
	 * by the expression tree.
	 *
	 * @return whether the system property is accessed or not
	 */
	public boolean hasSystemPropertyAccess() {
		return fHasSystemPropertyAccess;
	}

	
Marks the system property as accessed.
/**
	 * Marks the system property as accessed.
	 */
	public void markSystemPropertyAccessed() {
		fHasSystemPropertyAccess= true;
	}

	
Returns the set of accessed variables.
Returns:
the set of accessed variables/**
	 * Returns the set of accessed variables.
	 *
	 * @return the set of accessed variables
	 */
	public String[] getAccessedVariableNames() {
		if (fAccessedVariableNames == null)
			return new String[0];
		return fAccessedVariableNames.toArray(new String[fAccessedVariableNames.size()]);
	}

	
Marks the given variable as accessed.
Params:
name – the accessed variable/**
	 * Marks the given variable as accessed.
	 *
	 * @param name the accessed variable
	 */
	public void addVariableNameAccess(String name) {
		if (fAccessedVariableNames == null) {
			fAccessedVariableNames= new ArrayList<>(5);
			fAccessedVariableNames.add(name);
		} else {
			if (!fAccessedVariableNames.contains(name))
				fAccessedVariableNames.add(name);
		}
	}

	
Returns the set of accessed PropertyTester properties. 
See Also:
for system properties
Returns:
the fully qualified names of accessed properties, or an empty array
Since:
3.4/**
	 * Returns the set of accessed {@link PropertyTester} properties.
	 *
	 * @return the fully qualified names of accessed properties, or an empty array
	 *
	 * @see #hasSystemPropertyAccess() for system properties
	 * @since 3.4
	 */
	public String[] getAccessedPropertyNames() {
		if (fAccessedPropertyNames == null)
			return new String[0];
		return fAccessedPropertyNames.toArray(new String[fAccessedPropertyNames.size()]);
	}

	
Marks the given property (the fully qualified name of a PropertyTester property) as accessed. 
Params:
name – 
           the fully qualified property name
See Also:
for system properties
Since:
3.4/**
	 * Marks the given property (the fully qualified name of a
	 * {@link PropertyTester} property) as accessed.
	 *
	 * @param name
	 *            the fully qualified property name
	 *
	 * @see #markSystemPropertyAccessed() for system properties
	 * @since 3.4
	 */
	public void addAccessedPropertyName(String name) {
		if (fAccessedPropertyNames == null) {
			fAccessedPropertyNames= new ArrayList<>(5);
			fAccessedPropertyNames.add(name);
		} else {
			if (!fAccessedPropertyNames.contains(name))
				fAccessedPropertyNames.add(name);
		}
	}

	
Returns the set of expression types which don't reimplement the new Expression.collectExpressionInfo(ExpressionInfo) method. If one expression in the expression tree didn't implement the method, then no optimizations can be done. Returns null if
all expressions implement the method.
Returns:
the set of expression types which don't implement the
 computeReevaluationInfo method, or null if all do/**
	 * Returns the set of expression types which don't reimplement the
	 * new {@link Expression#collectExpressionInfo(ExpressionInfo)}
	 * method. If one expression in the expression tree didn't implement the
	 * method, then no optimizations can be done. Returns <code>null</code> if
	 * all expressions implement the method.
	 *
	 * @return the set of expression types which don't implement the
	 *  <code>computeReevaluationInfo</code> method, or <code>null</code> if all do
	 */
	public Class<?>[] getMisbehavingExpressionTypes() {
		if (fMisbehavingExpressionTypes == null)
			return null;
		return fMisbehavingExpressionTypes.toArray(new Class[fMisbehavingExpressionTypes.size()]);
	}

	
Adds the given class to the list of misbehaving classes.
Params:
clazz – the class to add./**
	 * Adds the given class to the list of misbehaving classes.
	 *
	 * @param clazz the class to add.
	 */
	public void addMisBehavingExpressionType(Class<?> clazz) {
		if (fMisbehavingExpressionTypes == null) {
			fMisbehavingExpressionTypes= new ArrayList<>(2);
			fMisbehavingExpressionTypes.add(clazz);
		} else {
			if (!fMisbehavingExpressionTypes.contains(clazz))
				fMisbehavingExpressionTypes.add(clazz);
		}
	}

	
Merges this reevaluation information with the given info.
Params:
other – the information to merge with/**
	 * Merges this reevaluation information with the given info.
	 *
	 * @param other the information to merge with
	 */
	public void merge(ExpressionInfo other) {
		mergeDefaultVariableAccess(other);
		mergeSystemPropertyAccess(other);

		mergeAccessedVariableNames(other);
		mergeAccessedPropertyNames(other);
		mergeMisbehavingExpressionTypes(other);
	}

	
Merges this reevaluation information with the given info
ignoring the default variable access.
Params:
other – the information to merge with/**
	 * Merges this reevaluation information with the given info
	 * ignoring the default variable access.
	 *
	 * @param other the information to merge with
	 */
	public void mergeExceptDefaultVariable(ExpressionInfo other) {
		mergeSystemPropertyAccess(other);

		mergeAccessedVariableNames(other);
		mergeAccessedPropertyNames(other);
		mergeMisbehavingExpressionTypes(other);
	}

	
Merges only the default variable access.
Params:
other – the information to merge with/**
	 * Merges only the default variable access.
	 *
	 * @param other the information to merge with
	 */
	private void mergeDefaultVariableAccess(ExpressionInfo other) {
		fHasDefaultVariableAccess= fHasDefaultVariableAccess || other.fHasDefaultVariableAccess;
	}

	
Merges only the system property access.
Params:
other – the information to merge with/**
	 * Merges only the system property access.
	 *
	 * @param other the information to merge with
	 */
	private void mergeSystemPropertyAccess(ExpressionInfo other) {
		fHasSystemPropertyAccess= fHasSystemPropertyAccess || other.fHasSystemPropertyAccess;
	}

	
Merges only the accessed variable names.
Params:
other – the information to merge with/**
	 * Merges only the accessed variable names.
	 *
	 * @param other the information to merge with
	 */
	private void mergeAccessedVariableNames(ExpressionInfo other) {
		if (fAccessedVariableNames == null) {
			fAccessedVariableNames= other.fAccessedVariableNames; //TODO: shares the two lists! Can propagate further additions up into sibling branches.
		} else {
			if (other.fAccessedVariableNames != null) {
				for (String variableName : other.fAccessedVariableNames) {
					if (!fAccessedVariableNames.contains(variableName))
						fAccessedVariableNames.add(variableName);
				}
			}
		}
	}

	
Merges only the accessed property names.
Params:
other – the information to merge with
See Also:
for system properties
Since:
3.4/**
	 * Merges only the accessed property names.
	 *
	 * @param other the information to merge with
	 * @see #mergeSystemPropertyAccess(ExpressionInfo) for system properties
	 * @since 3.4
	 */
	private void mergeAccessedPropertyNames(ExpressionInfo other) {
		if (fAccessedPropertyNames == null) {
			fAccessedPropertyNames= other.fAccessedPropertyNames; //TODO: shares the two lists!
		} else {
			if (other.fAccessedPropertyNames != null) {
				for (String variableName : other.fAccessedPropertyNames) {
					if (!fAccessedPropertyNames.contains(variableName))
						fAccessedPropertyNames.add(variableName);
				}
			}
		}
	}

	
Merges only the misbehaving expression types.
Params:
other – the information to merge with/**
	 * Merges only the misbehaving expression types.
	 *
	 * @param other the information to merge with
	 */
	private void mergeMisbehavingExpressionTypes(ExpressionInfo other) {
		if (fMisbehavingExpressionTypes == null) {
			fMisbehavingExpressionTypes= other.fMisbehavingExpressionTypes; //TODO: shares the two lists!
		} else  {
			if (other.fMisbehavingExpressionTypes != null) {
				for (Class<?> clazz : other.fMisbehavingExpressionTypes) {
					if (!fMisbehavingExpressionTypes.contains(clazz))
						fMisbehavingExpressionTypes.add(clazz);
				}
			}
		}
	}
}