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
|
/*******************************************************************************
* Copyright (c) 2000, 2005 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.jface.text.templates;
import java.util.HashMap;
import java.util.Map;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.jface.text.BadLocationException;
/**
* Provides the context for a <code>Template</code> being resolved. Keeps track
* of resolved variables.
* <p>
* Clients may extend this class.
* </p>
*
* @since 3.0
*/
public abstract class TemplateContext implements IAdaptable {
/** The context type of this context */
private final TemplateContextType fContextType;
/** Additional variables. */
private final Map<String, String> fVariables= new HashMap<>();
/** A flag to indicate that the context should not be modified. */
private boolean fReadOnly;
/**
* Creates a template context of a particular context type.
*
* @param contextType the context type of this context
*/
protected TemplateContext(TemplateContextType contextType) {
fContextType= contextType;
fReadOnly= true;
}
/**
* Returns the context type of this context.
*
* @return the context type of this context
*/
public TemplateContextType getContextType() {
return fContextType;
}
/**
* Sets or clears the read-only flag.
*
* @param readOnly the new read-only state
*/
public void setReadOnly(boolean readOnly) {
fReadOnly= readOnly;
}
/**
* Returns <code>true</code> if the receiver is read-only, <code>false</code> otherwise.
*
* @return <code>true</code> if the receiver is read-only, <code>false</code> otherwise
*/
public boolean isReadOnly() {
return fReadOnly;
}
/**
* Defines the value of a variable.
*
* @param name the name of the variable
* @param value the value of the variable, <code>null</code> to un-define a variable
*/
public void setVariable(String name, String value) {
fVariables.put(name, value);
}
/**
* Returns the value of a defined variable.
*
* @param name the name of the variable
* @return returns the value of the variable, <code>null</code> if the variable was not defined
*/
public String getVariable(String name) {
return fVariables.get(name);
}
/**
* Evaluates the template in this context and returns a template buffer.
* <p>
* Evaluation means translating the template into a <code>TemplateBuffer</code>,
* resolving the defined variables in this context and possibly formatting
* the resolved buffer.</p>
*
* @param template the template to evaluate
* @return returns the buffer with the evaluated template or <code>null</code> if the buffer could not be created
* @throws BadLocationException if evaluation fails due to concurrently changed documents etc.
* @throws TemplateException if the template specification is not valid
*/
public abstract TemplateBuffer evaluate(Template template) throws BadLocationException, TemplateException;
/**
* Tests if the specified template can be evaluated in this context.
* <p>Examples are templates defined for a different context (e.g. a javadoc
* template cannot be evaluated in Java context).</p>
*
* @param template the <code>Template</code> to check
* @return <code>true</code> if <code>template</code> can be evaluated
* in this context, <code>false</code> otherwise
*/
public abstract boolean canEvaluate(Template template);
/**
* Default implementation does nothing, clients can override to provide adapters.
* {@inheritDoc}
*/
@Override
public <T> T getAdapter(Class<T> adapter) {
return null;
}
}
|
