org.eclipse.jface.text.templates.TemplateVariable Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of aspectjtools Show documentation
Show all versions of aspectjtools Show documentation
AspectJ tools most notably contains the AspectJ compiler (AJC). AJC applies aspects to Java classes during
compilation, fully replacing Javac for plain Java classes and also compiling native AspectJ or annotation-based
@AspectJ syntax. Furthermore, AJC can weave aspects into existing class files in a post-compile binary weaving step.
This library is a superset of AspectJ weaver and hence also of AspectJ runtime.
/*******************************************************************************
* Copyright (c) 2000, 2021 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
* Christoph Läubrich - Bug 570519 - Allow to specify TemplateVariable#fInitialLength
*******************************************************************************/
package org.eclipse.jface.text.templates;
import org.eclipse.core.runtime.Assert;
import org.eclipse.jface.text.TextUtilities;
/**
* A TemplateVariable represents a set of positions into a
* TemplateBuffer with identical content each. TemplateVariableResolvers
* can be used to resolve a template variable to a symbol available from the
* TemplateContext. A resolved variable may have one or more possible
* {@link #getValues() values} which may be presented to the user as choices. If there is no user
* interaction the {@link #getDefaultValue() default value} is chosen as textual representation of
* the variable.
*
* Clients may instantiate and extend this class.
*
*
* @see TemplateVariableResolver
* @see TemplateBuffer
* @since 3.0
*/
public class TemplateVariable {
/** The type name of the variable */
private final TemplateVariableType fType;
/** The name of the variable. */
private final String fName;
/** The initial length in the template pattern. */
private final int fInitialLength;
/** The offsets of the variable. */
private int[] fOffsets;
/** Flag indicating if the variable has been resolved unambiguously. */
private boolean fIsUnambiguous;
/** Flag indicating if the variable has been resolved by a resolver. */
private boolean fIsResolved;
/**
* The proposal strings available for this variable. The first string is
* the default value.
*/
private String[] fValues;
/**
* Creates a template variable. The type is used as the name of the
* variable.
*
* @param type the type of the variable
* @param defaultValue the default value of the variable
* @param offsets the array of offsets of the variable
*/
public TemplateVariable(String type, String defaultValue, int[] offsets) {
this(type, new String[] { defaultValue }, offsets);
}
/**
* Creates a template variable.
*
* @param type the type of the variable
* @param name the name of the variable
* @param defaultValue the default value of the variable
* @param offsets the array of offsets of the variable
*/
public TemplateVariable(String type, String name, String defaultValue, int[] offsets) {
this(type, name, new String[] { defaultValue }, offsets);
}
/**
* Creates a template variable.
*
* @param type the type of the variable
* @param name the name of the variable
* @param defaultValue the default value of the variable
* @param offsets the array of offsets of the variable
* @since 3.3
*/
public TemplateVariable(TemplateVariableType type, String name, String defaultValue, int[] offsets) {
this(type, name, new String[] { defaultValue }, offsets, defaultValue.length());
}
/**
* Creates a template variable with multiple possible values. The type is
* used as the name of the template.
*
* @param type the type of the template variable
* @param values the values available at this variable, non-empty
* @param offsets the array of offsets of the variable
*/
public TemplateVariable(String type, String[] values, int[] offsets) {
this(type, type, values, offsets);
}
/**
* Creates a template variable with multiple possible values.
*
* @param type the type of the variable
* @param name the name of the variable
* @param values the values available at this variable, non-empty
* @param offsets the array of offsets of the variable
*/
public TemplateVariable(String type, String name, String[] values, int[] offsets) {
this(type, name, values, offsets, values[0].length());
}
/**
* Creates a template variable with multiple possible values.
*
* @param type the type of the variable
* @param name the name of the variable
* @param values the values available at this variable, non-empty
* @param offsets the array of offsets of the variable
* @param length the length of the variable in the template at offset positions
* @since 3.11
*/
public TemplateVariable(String type, String name, String[] values, int[] offsets, int length) {
this(new TemplateVariableType(type), name, values, offsets, length);
}
/**
* Creates a template variable with multiple possible values.
*
* @param type the type of the variable
* @param name the name of the variable
* @param values the values available at this variable, non-empty
* @param offsets the array of offsets of the variable
* @param initialLength the length of the variable in the template
* @since 3.3
*/
TemplateVariable(TemplateVariableType type, String name, String[] values, int[] offsets, int initialLength) {
Assert.isNotNull(type);
Assert.isNotNull(name);
fInitialLength= initialLength;
fType= type;
fName= name;
setValues(values);
setOffsets(offsets);
setUnambiguous(false);
setResolved(false);
}
/**
* Returns the type name of the variable.
*
* @return the type name of the variable
*/
public String getType() {
return fType.getName();
}
/**
* Returns the type of the variable.
*
* @return the type of the variable
* @since 3.3
*/
public TemplateVariableType getVariableType() {
return fType;
}
/**
* Returns the name of the variable.
*
* @return the name of the variable
*/
public String getName() {
return fName;
}
/**
* Returns the default value of the variable. Typically, this is the first of
* the possible values (see {@link #getValues()}.
*
* @return the default value of the variable
*/
public String getDefaultValue() {
return getValues()[0];
}
/**
* Returns the possible values for this variable. The returned array is owned by this variable
* and must not be modified. The array is not empty.
*
* @return the possible values for this variable
*/
public String[] getValues() {
return fValues;
}
/**
* Returns the length of the variable's default value.
*
* @return the length of the variable
*/
public int getLength() {
return getDefaultValue().length();
}
/**
* Returns the initial length of the variable. The initial length is the lenght as it occurred
* in the template pattern and is used when resolving a template to update the pattern with the
* resolved values of the variable.
*
* @return the initial length of the variable
* @since 3.11
*/
public final int getInitialLength() {
return fInitialLength;
}
/**
* Sets the offsets of the variable.
*
* @param offsets the new offsets of the variable
*/
public void setOffsets(int[] offsets) {
fOffsets= TextUtilities.copy(offsets);
}
/**
* Returns the offsets of the variable. The returned array is
* owned by this variable and must not be modified.
*
* @return the length of the variable
*/
public int[] getOffsets() {
return fOffsets;
}
/**
* Resolves the variable to a single value. This is a shortcut for
* setValues(new String[] { value }).
*
* @param value the new default value
*/
public final void setValue(String value) {
setValues(new String[] { value });
}
/**
* Resolves the variable to several possible values for this variable, with the first being the
* default value.
*
* @param values a non-empty array of values
*/
public void setValues(String[] values) {
Assert.isTrue(values.length > 0);
fValues= TextUtilities.copy(values);
setResolved(true);
}
/**
* Sets the isUnambiguous flag of the variable.
*
* @param unambiguous the new unambiguous state of the variable
*/
public void setUnambiguous(boolean unambiguous) {
fIsUnambiguous= unambiguous;
if (unambiguous)
setResolved(true);
}
/**
* Returns true if the variable is unambiguously resolved, false otherwise.
*
* @return true if the variable is unambiguously resolved, false otherwise
*/
public boolean isUnambiguous() {
return fIsUnambiguous;
}
/**
* Sets the resolved flag of the variable.
*
* @param resolved the new resolved state
* @since 3.3
*/
public void setResolved(boolean resolved) {
fIsResolved= resolved;
}
/**
* Returns true if the variable has been resolved, false
* otherwise.
*
* @return true if the variable has been resolved, false otherwise
* @since 3.3
*/
public boolean isResolved() {
return fIsResolved;
}
}