Skip to main content
aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to 'org.eclipse.text/src/org/eclipse/text/templates/TemplateStoreCore.java')
-rw-r--r--org.eclipse.text/src/org/eclipse/text/templates/TemplateStoreCore.java504
1 files changed, 504 insertions, 0 deletions
diff --git a/org.eclipse.text/src/org/eclipse/text/templates/TemplateStoreCore.java b/org.eclipse.text/src/org/eclipse/text/templates/TemplateStoreCore.java
new file mode 100644
index 000000000..a83edce2d
--- /dev/null
+++ b/org.eclipse.text/src/org/eclipse/text/templates/TemplateStoreCore.java
@@ -0,0 +1,504 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2018 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.text.templates;
+
+import java.io.IOException;
+import java.io.Reader;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.osgi.service.prefs.BackingStoreException;
+
+import org.eclipse.core.runtime.Assert;
+import org.eclipse.core.runtime.preferences.IEclipsePreferences;
+import org.eclipse.core.runtime.preferences.IEclipsePreferences.IPreferenceChangeListener;
+import org.eclipse.core.runtime.preferences.IEclipsePreferences.PreferenceChangeEvent;
+
+import org.eclipse.text.templates.ContextTypeRegistry;
+import org.eclipse.text.templates.TemplatePersistenceData;
+
+import org.eclipse.jface.text.templates.Template;
+import org.eclipse.jface.text.templates.TemplateException;
+
+/**
+ * A collection of templates. Clients may instantiate this class. In order to
+ * load templates contributed using the <code>org.eclipse.ui.editors.templates</code>
+ * extension point, use a <code>ContributionTemplateStore</code>.
+ *
+ * @since 3.7
+ */
+public class TemplateStoreCore {
+
+ /** The stored templates. */
+ private final List<TemplatePersistenceData> fTemplates= new ArrayList<>();
+ /** The preference store. */
+ private IEclipsePreferences fPreferenceStore;
+ /**
+ * The key into <code>fPreferenceStore</code> the value of which holds custom templates
+ * encoded as XML.
+ */
+ private String fKey;
+ /**
+ * The context type registry, or <code>null</code> if all templates regardless
+ * of context type should be loaded.
+ */
+ private ContextTypeRegistry fRegistry;
+ /**
+ * Set to <code>true</code> if property change events should be ignored (e.g. during writing
+ * to the preference store).
+ *
+ * @since 3.2
+ */
+ private boolean fIgnorePreferenceStoreChanges= false;
+ /**
+ * The property listener, if any is registered, <code>null</code> otherwise.
+ *
+ * @since 3.2
+ */
+ private IPreferenceChangeListener fPropertyListener;
+
+
+ /**
+ * Creates a new template store.
+ *
+ * @param store the preference store in which to store custom templates
+ * under <code>key</code>
+ * @param key the key into <code>store</code> where to store custom
+ * templates
+ */
+ public TemplateStoreCore(IEclipsePreferences store, String key) {
+ Assert.isNotNull(key);
+ fPreferenceStore= store;
+ fKey= key;
+ }
+
+ /**
+ * Creates a new template store with a context type registry. Only templates
+ * that specify a context type contained in the registry will be loaded by
+ * this store if the registry is not <code>null</code>.
+ *
+ * @param registry a context type registry, or <code>null</code> if all
+ * templates should be loaded
+ * @param store the preference store in which to store custom templates
+ * under <code>key</code>
+ * @param key the key into <code>store</code> where to store custom
+ * templates
+ */
+ public TemplateStoreCore(ContextTypeRegistry registry, IEclipsePreferences store, String key) {
+ this(store, key);
+ fRegistry= registry;
+ }
+
+ /**
+ * Loads the templates from contributions and preferences.
+ *
+ * @throws IOException if loading fails.
+ */
+ public void load() throws IOException {
+ fTemplates.clear();
+ loadContributedTemplates();
+ loadCustomTemplates();
+ }
+
+ /**
+ * Starts listening for property changes on the preference store. If the configured preference
+ * key changes, the template store is {@link #load() reloaded}. Call
+ * {@link #stopListeningForPreferenceChanges()} to remove any listener and stop the
+ * auto-updating behavior.
+ *
+ * @since 3.2
+ */
+ public void startListeningForPreferenceChanges() {
+ if (fPropertyListener == null) {
+ fPropertyListener= new IPreferenceChangeListener() {
+ @Override
+ public void preferenceChange(PreferenceChangeEvent event) {
+ /*
+ * Don't load if we are in the process of saving ourselves. We are in sync anyway after the
+ * save operation, and clients may trigger reloading by listening to preference store
+ * updates.
+ */
+ if (!fIgnorePreferenceStoreChanges && fKey.equals(event.getKey()))
+ try {
+ load();
+ } catch (IOException x) {
+ handleException(x);
+ }
+ }
+ };
+ fPreferenceStore.addPreferenceChangeListener(fPropertyListener);
+ }
+
+ }
+
+ /**
+ * Stops the auto-updating behavior started by calling
+ * {@link #startListeningForPreferenceChanges()}.
+ *
+ * @since 3.2
+ */
+ public void stopListeningForPreferenceChanges() {
+ if (fPropertyListener != null) {
+ fPreferenceStore.removePreferenceChangeListener(fPropertyListener);
+ fPropertyListener= null;
+ }
+ }
+
+ /**
+ * Handles an {@link IOException} thrown during reloading the preferences due to a preference
+ * store update. The default is to write to stderr.
+ *
+ * @param x the exception
+ * @since 3.2
+ */
+ protected void handleException(IOException x) {
+ x.printStackTrace();
+ }
+
+ /**
+ * Hook method to load contributed templates. Contributed templates are superseded
+ * by customized versions of user added templates stored in the preferences.
+ * <p>
+ * The default implementation does nothing.</p>
+ *
+ * @throws IOException if loading fails
+ */
+ protected void loadContributedTemplates() throws IOException {
+ }
+
+ /**
+ * Adds a template to the internal store. The added templates must have
+ * a unique id.
+ *
+ * @param data the template data to add
+ */
+ protected void internalAdd(TemplatePersistenceData data) {
+ if (!data.isCustom()) {
+ // check if the added template is not a duplicate id
+ String id= data.getId();
+ for (TemplatePersistenceData persistenceData : fTemplates) {
+ if (persistenceData.getId() != null && persistenceData.getId().equals(id))
+ return;
+ }
+ fTemplates.add(data);
+ }
+ }
+
+ /**
+ * Saves the templates to the preferences.
+ *
+ * @throws IOException if the templates cannot be written
+ */
+ public void save() throws IOException {
+ ArrayList<TemplatePersistenceData> custom= new ArrayList<>();
+ for (TemplatePersistenceData data : fTemplates) {
+ if (data.isCustom() && !(data.isUserAdded() && data.isDeleted())) // don't save deleted user-added templates
+ custom.add(data);
+ }
+
+ StringWriter output= new StringWriter();
+ TemplateReaderWriter writer= new TemplateReaderWriter();
+ writer.save(custom.toArray(new TemplatePersistenceData[custom.size()]), output);
+
+ fIgnorePreferenceStoreChanges= true;
+ try {
+ fPreferenceStore.put(fKey, output.toString());
+ fPreferenceStore.flush();
+ } catch (BackingStoreException e) {
+ } finally {
+ fIgnorePreferenceStoreChanges= false;
+ }
+ }
+
+ /**
+ * Adds a template encapsulated in its persistent form.
+ *
+ * @param data the template to add
+ */
+ public void add(TemplatePersistenceData data) {
+
+ if (!validateTemplate(data.getTemplate()))
+ return;
+
+ if (data.isUserAdded()) {
+ fTemplates.add(data);
+ } else {
+ for (TemplatePersistenceData persistenceData : fTemplates) {
+ if (persistenceData.getId() != null && persistenceData.getId().equals(data.getId())) {
+ persistenceData.setTemplate(data.getTemplate());
+ persistenceData.setDeleted(data.isDeleted());
+ persistenceData.setEnabled(data.isEnabled());
+ return;
+ }
+ }
+
+ // add an id which is not contributed as add-on
+ if (data.getTemplate() != null) {
+ TemplatePersistenceData newData= new TemplatePersistenceData(data.getTemplate(), data.isEnabled(), data.getId());
+ fTemplates.add(newData);
+ }
+ }
+ }
+
+ /**
+ * Removes a template from the store.
+ *
+ * @param data the template to remove
+ */
+ public void delete(TemplatePersistenceData data) {
+ if (data.isUserAdded())
+ fTemplates.remove(data);
+ else
+ data.setDeleted(true);
+ }
+
+ /**
+ * Restores all contributed templates that have been deleted.
+ */
+ public void restoreDeleted() {
+ for (TemplatePersistenceData data : fTemplates) {
+ if (data.isDeleted())
+ data.setDeleted(false);
+ }
+ }
+
+ /**
+ * Deletes all user-added templates and reverts all contributed templates.
+ *
+ * @param doSave <code>true</code> if the store should be saved after restoring
+ * @since 3.5
+ */
+ public void restoreDefaults(boolean doSave) {
+ String oldValue= null;
+ if (!doSave)
+ oldValue= fPreferenceStore.get(fKey, null);
+
+ try {
+ fIgnorePreferenceStoreChanges= true;
+ // See IPreferenceStore for default String value
+ fPreferenceStore.put(fKey, ""); //$NON-NLS-1$
+ } finally {
+ fIgnorePreferenceStoreChanges= false;
+ }
+
+ try {
+ load();
+ } catch (IOException x) {
+ // can't log from jface-text
+ handleException(x);
+ }
+
+ if (oldValue != null) {
+ try {
+ fIgnorePreferenceStoreChanges= true;
+ fPreferenceStore.put(fKey, oldValue);
+ } finally {
+ fIgnorePreferenceStoreChanges= false;
+ }
+ }
+ }
+
+ /**
+ * Deletes all user-added templates and reverts all contributed templates.
+ * <p>
+ * <strong>Note:</strong> the store will be saved after restoring.
+ * </p>
+ */
+ public void restoreDefaults() {
+ restoreDefaults(true);
+ }
+
+ /**
+ * Returns all enabled templates.
+ *
+ * @return all enabled templates
+ */
+ public Template[] getTemplates() {
+ return getTemplates(null);
+ }
+
+ /**
+ * Returns all enabled templates for the given context type.
+ *
+ * @param contextTypeId the id of the context type of the requested templates, or <code>null</code> if all templates should be returned
+ * @return all enabled templates for the given context type
+ */
+ public Template[] getTemplates(String contextTypeId) {
+ List<Template> templates= new ArrayList<>();
+ for (TemplatePersistenceData data : fTemplates) {
+ if (data.isEnabled() && !data.isDeleted() && (contextTypeId == null || contextTypeId.equals(data.getTemplate().getContextTypeId())))
+ templates.add(data.getTemplate());
+ }
+
+ return templates.toArray(new Template[templates.size()]);
+ }
+
+ /**
+ * Returns the first enabled template that matches the name.
+ *
+ * @param name the name of the template searched for
+ * @return the first enabled template that matches both name and context type id, or <code>null</code> if none is found
+ */
+ public Template findTemplate(String name) {
+ return findTemplate(name, null);
+ }
+
+ /**
+ * Returns the first enabled template that matches both name and context type id.
+ *
+ * @param name the name of the template searched for
+ * @param contextTypeId the context type id to clip unwanted templates, or <code>null</code> if any context type is OK
+ * @return the first enabled template that matches both name and context type id, or <code>null</code> if none is found
+ */
+ public Template findTemplate(String name, String contextTypeId) {
+ Assert.isNotNull(name);
+
+ for (TemplatePersistenceData data : fTemplates) {
+ Template template= data.getTemplate();
+ if (data.isEnabled() && !data.isDeleted()
+ && (contextTypeId == null || contextTypeId.equals(template.getContextTypeId()))
+ && name.equals(template.getName()))
+ return template;
+ }
+
+ return null;
+ }
+
+ /**
+ * Returns the first enabled template that matches the given template id.
+ *
+ * @param id the id of the template searched for
+ * @return the first enabled template that matches id, or <code>null</code> if none is found
+ * @since 3.1
+ */
+ public Template findTemplateById(String id) {
+ TemplatePersistenceData data= getTemplateData(id);
+ if (data != null && !data.isDeleted())
+ return data.getTemplate();
+
+ return null;
+ }
+
+ /**
+ * Returns all template data.
+ *
+ * @param includeDeleted whether to include deleted data
+ * @return all template data, whether enabled or not
+ */
+ public TemplatePersistenceData[] getTemplateData(boolean includeDeleted) {
+ List<TemplatePersistenceData> datas= new ArrayList<>();
+ for (TemplatePersistenceData data : fTemplates) {
+ if (includeDeleted || !data.isDeleted())
+ datas.add(data);
+ }
+
+ return datas.toArray(new TemplatePersistenceData[datas.size()]);
+ }
+
+ /**
+ * Returns the template data of the template with id <code>id</code> or
+ * <code>null</code> if no such template can be found.
+ *
+ * @param id the id of the template data
+ * @return the template data of the template with id <code>id</code> or <code>null</code>
+ * @since 3.1
+ */
+ public TemplatePersistenceData getTemplateData(String id) {
+ Assert.isNotNull(id);
+ for (TemplatePersistenceData data : fTemplates) {
+ if (id.equals(data.getId()))
+ return data;
+ }
+
+ return null;
+ }
+
+ private void loadCustomTemplates() throws IOException {
+ String pref= fPreferenceStore.get(fKey, null);
+ if (pref != null && pref.trim().length() > 0) {
+ Reader input= new StringReader(pref);
+ TemplateReaderWriter reader= new TemplateReaderWriter();
+ TemplatePersistenceData[] datas= reader.read(input);
+ for (TemplatePersistenceData data : datas) {
+ add(data);
+ }
+ }
+ }
+
+ /**
+ * Validates a template against the context type registered in the context
+ * type registry. Returns always <code>true</code> if no registry is
+ * present.
+ *
+ * @param template the template to validate
+ * @return <code>true</code> if validation is successful or no context
+ * type registry is specified, <code>false</code> if validation
+ * fails
+ */
+ private boolean validateTemplate(Template template) {
+ String contextTypeId= template.getContextTypeId();
+ if (contextExists(contextTypeId)) {
+ if (fRegistry != null)
+ try {
+ fRegistry.getContextType(contextTypeId).validate(template.getPattern());
+ } catch (TemplateException e) {
+ return false;
+ }
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * Returns <code>true</code> if a context type id specifies a valid context type
+ * or if no context type registry is present.
+ *
+ * @param contextTypeId the context type id to look for
+ * @return <code>true</code> if the context type specified by the id
+ * is present in the context type registry, or if no registry is
+ * specified
+ */
+ private boolean contextExists(String contextTypeId) {
+ return contextTypeId != null && (fRegistry == null || fRegistry.getContextType(contextTypeId) != null);
+ }
+
+ /**
+ * Returns the registry.
+ *
+ * @return Returns the registry
+ */
+ protected ContextTypeRegistry getRegistry() {
+ return fRegistry;
+ }
+
+ /**
+ * Return the key into the Preference Store whose value contains
+ * the custom templates encoded as XML.
+ *
+ * @return the key in the Preference Store
+ */
+ protected final String getKey () {
+ return fKey;
+ }
+
+ /**
+ * Return the stored templates
+ * @return the stored templates
+ */
+ protected final List<TemplatePersistenceData> internalGetTemplates () {
+ return fTemplates;
+ }
+
+}
+

Back to the top