Skip to main content
aboutsummaryrefslogtreecommitdiffstats
blob: ae2b5124a9e2a2f7d5b59d45a81221994447de9f (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jface.text.templates;

import org.eclipse.jface.text.Assert;

/**
 * A <code>TemplateVariableResolver</code> resolves <code>TemplateVariables</code>
 * of a certain type inside a <code>TemplateContext</code>.
 * <p>
 * Clients may instantiate and extend this class.
 * </p>
 * 
 * @see TemplateVariable
 * @since 3.0
 */
public class TemplateVariableResolver {

	/** Type of this resolver. */
	private String fType= null;

	/** Description of the type resolved by this resolver. */
	private String fDescription= null;
	
	/**
	 * Creates an instance of <code>TemplateVariableResolver</code>.
	 * 
	 * @param type the name of the type
	 * @param description the description for the type
	 */
	protected TemplateVariableResolver(String type, String description) {
	 	setType(type);   
	 	setDescription(description);
	}
	
	/**
	 * Creates an empty instance.
	 * <p>
	 * This is a framework-only constructor that exists only so that resolvers
	 * can be contributed via an extension point and that should not be called
	 * in client code except for subclass constructors; use
	 * {@link #TemplateVariableResolver(String, String)} instead.
	 * </p>
	 */
	public TemplateVariableResolver() {
	}
	
	/**
	 * Returns the type of this resolver.
	 * 
	 * @return the type
	 */
	public String getType() {
		return fType;
	}

	/**
	 * Returns the description for the resolver.
	 * 
	 * @return the description for the resolver
	 */
	public String getDescription() {
		return fDescription;   
	}

	/**
	 * Returns an instance of the type resolved by the receiver available in <code>context</code>.
	 * To resolve means to provide a binding to a concrete text object (a
	 * <code>String</code>) in the given context.
	 * <p>
	 * The default implementation looks up the type in the context.</p>
	 * 
	 * @param context the context in which to resolve the type
	 * @return the name of the text object of this type, or <code>null</code> if it cannot be determined
	 */
	protected String resolve(TemplateContext context) {
		return context.getVariable(getType());
	}
	
	/**
	 * Returns all possible bindings available in <code>context</code>. The default
	 * implementation simply returns an array which contains the result of 
	 * {@link #resolve(TemplateContext)}, or an empty array if that call returns
	 * <code>null</code>.
	 * 
	 * @param context the context in which to resolve the type
	 * @return an array of possible bindings of this type in <code>context</code>
	 */
	protected String[] resolveAll(TemplateContext context) {
		String binding= resolve(context);
		if (binding == null)
			return new String[0];
		else
			return new String[] { binding };
	}
	
	/**
	 * Resolves <code>variable</code> in <code>context</code>. To resolve
	 * means to find a valid binding of the receiver's type in the given <code>TemplateContext</code>.
	 * If the variable can be successfully resolved, its value is set using
	 * {@link TemplateVariable#setValues(String[])}.
	 * 
	 * @param context the context in which variable is resolved
	 * @param variable the variable to resolve
	 */
	public void resolve(TemplateVariable variable, TemplateContext context) {
		String[] bindings= resolveAll(context);
		if (bindings.length != 0)
			variable.setValues(bindings);
		if (bindings.length > 1)
			variable.setUnambiguous(false);
		else
			variable.setUnambiguous(isUnambiguous(context));
	}

	/**
	 * Returns whether this resolver is able to resolve unambiguously. When
	 * resolving a <code>TemplateVariable</code>, its <code>isUmambiguous</code>
	 * state is set to the one of this resolver. By default, this method
	 * returns <code>false</code>. Clients can overwrite this method to give
	 * a hint about whether there should be e.g. prompting for input values for
	 * ambiguous variables.
	 * 
	 * @param context the context in which the resolved check should be
	 *        evaluated
	 * @return <code>true</code> if the receiver is unambiguously resolvable
	 *         in <code>context</code>, <code>false</code> otherwise
	 */
	protected boolean isUnambiguous(TemplateContext context) {
		return false;
	}
	
	/**
	 * Sets the description.
	 * <p>
	 * This is a framework-only method that exists only so that resolvers
	 * can be contributed via an extension point and that should not be called
	 * in client code; use {@link #TemplateVariableResolver(String, String)} instead.
	 * </p>
	 * 
	 * @param description the description of this resolver
	 */
	public final void setDescription(String description) {
		Assert.isNotNull(description);
		Assert.isTrue(fDescription == null); // may only be called once when initialized
		fDescription= description;
	}
	
	/**
	 * Sets the type.
	 * <p>
	 * This is a framework-only method that exists only so that resolvers
	 * can be contributed via an extension point and that should not be called
	 * in client code; use {@link #TemplateVariableResolver(String, String)} instead.
	 * </p>
	 * 
	 * @param type the type of this resolver
	 */
	public final void setType(String type) {
		Assert.isNotNull(type);
		Assert.isTrue(fType == null); // may only be called once when initialized
		fType= type;
	}
}

Back to the top