It is a module located under ide/editor.codetemplates directory.
It consists of
Code Templates define CodeTemplatesAPI.
-
Sep 9 '21 Default method
createFilter(Document, int, int) added to CodeTemplateFilter.Factory.
Added method allows creating code template filters for the given document and range.
-
Aug 15 '16 Added
ordering for code template parameters.
The ordering attribute defines the sequence in which placeholders arecompleted. Use 0 for the first element, 1 for the second... Placeholders
without ordering information will be placed after the last placeholder with ordering information.
Example of ordering of parameters :
// paramC comes first, then paramB, then paramA
${paramA} ${paramB ordering=2} ${paramC ordering=1}
-
May 3 '13 Added
CodeTemplateFilter.ContextBasedFactory.
Added interface CodeTemplateFilter.ContextBasedFactory
with the getSupportedContexts() method as an extension
to the exisitng CodeTemplateFilter.Factory
that allows for specifying all the possible context values
valid for the given language (supported by the particular
CodeTemplateFilters that the factory creates).
-
Jul 27 '05 Editor Code Templates API created
Editor Code Templates API was created.
Use Cases
Code Template Parameters
One of the main benefits of the code templates is their parametrization
which allows to substitute the default values for the parameters
before the final insertion and it also allows the user to modify
these default values explicitly after the code template gets inserted
into the document.
The parameters are marked in the code template's text by ${...}.
Parameters of the same name benefit from automatic replication. Once the template
gets pasted into the document all the parameter's occurrences
get replaced by parameter's default value.
The first parameter's occurrence gets selected.
The user can now replace the default value. If the user does so the new value
gets replicated to all the other occurrences of this parameter automatically.
Mime-type specific operation
Each code template needs to find the default values for its parameters
before it gets inserted into the text.
Sometimes it's enough to just specify the default value in the template's text
but usually the default value gets determined from the context of insertion.
There is an intent to create a mime-type specific code template processor
that would be registered per mime-type. There could be even more than one
such processors processing the template in a specific order.
Parameter hints
Besides parameter's name the template processors may need additional
hints of how to find a default value for the parameter.
For example java code template's parameter may be an index
parameter which means that the infrastructure should fill in
a fresh index variable e.g. i.
Or the parameter can only be of a certain java type such
as in the case of iterating through a collection
the type must be subtype of java.util.Collection.
These requirements could be specified as additional hints
to the parameters e.g. ${i index}
or ${c instanceof=java.util.Collection}.
The hints allow string literals to support arbitrary
explicit default values specifications
e.g. ${x default="Hello world"}.
The '{' and '}' have no special meaning inside the string literal.
The '"' char is allowed to be used by escaping
${x default="\"quoted string\""}.
Temporary Code Templates
The Code Completion functionality allows to build temporary
Code Templates functionality if it could build a temporary template
for completing of the method parameters. The parameters could
be completed one by one by tabbing and the Code Templates framework
would fill in proper default values just like it does for regular templates.
JTextComponent pane = ...
String tempCodeTemplateText = ...
CodeTemplate ct = CodeTemplateManager.get(pane.getDocument()).createTemporary(tempCodeTemplateText);
ct.insert(pane);
Insert Text Building and Updating
The parametrized text of the code template first gets parsed
and the parameters get their default values which by default are
the names of the parameters.
The code template processor are then called to update this default
value.
The new java infrastructure being developed would benefit
from the possibility to obtain the full string containing
the skeleton of the code template (without parameters)
with the present default values. It can take that string
and locally parse it to find out types of local variables
used in the particular template and fill in dependent
variable types.
Parameter Editability
Certain part of the code template may change text but it should
not be edited by the user. For example when iterating over collection
given as a parameter the collection may be generics-ed
by additional type. The iterator's variable type then also
needs to generics-ed with the same type.
The iterator's type parameter should not be editable because
this operation may be done automatically
by the java code template processor.
There should be a hint editable having
true/false.
Exported Interfaces
This table lists all of the module exported APIs
with
defined stability classifications. It is generated
based on answers to questions about the architecture
of the module.
Read them all...
Group of java interfaces
| Interface Name | In/Out | Stability | Specified in What Document? |
| CodeTemplatesAPI | Exported | Stable | |
|
Group of lookup interfaces
| Interface Name | In/Out | Stability | Specified in What Document? |
|
Implementation Details
Where are the sources for the module?
The sources for the module are in the
Apache Git repositories
or in the GitHub repositories.
What do other modules need to do to declare a dependency on this one, in addition to or instead of a plain module dependency?
Nothing.
Read more about the implementation in the answers to
architecture questions.