Java TemplateException类代码示例

import org.eclipse.jface.text.templates.TemplateException; //导入依赖的package包/类
@Override
public TemplateBuffer evaluate(Template template) throws BadLocationException, TemplateException {
	// test that all variables are defined
	Iterator<TemplateVariableResolver> iterator= getContextType().resolvers();
	while (iterator.hasNext()) {
		TemplateVariableResolver var= iterator.next();
		if (var instanceof CodeTemplateContextType.CodeTemplateVariableResolver) {
			Assert.isNotNull(getVariable(var.getType()), "Variable " + var.getType() + "not defined"); //$NON-NLS-1$ //$NON-NLS-2$
		}
	}

	if (!canEvaluate(template)) {
		return null;
	}

	String pattern= changeLineDelimiter(template.getPattern(), fLineDelimiter);

	TemplateTranslator translator= new TemplateTranslator();
	TemplateBuffer buffer= translator.translate(pattern);
	getContextType().resolve(buffer, this);
	return buffer;
}
 

import org.eclipse.jface.text.templates.TemplateException; //导入依赖的package包/类
@Override
protected void validateVariables(TemplateVariable[] variables) throws TemplateException {
	ArrayList<String> required = new ArrayList<>(5);
	String contextName = getId();
	if (NEWTYPE_CONTEXTTYPE.equals(contextName)) {
		required.add(PACKAGE_DECLARATION);
		required.add(TYPE_DECLARATION);
	}
	for (int i = 0; i < variables.length; i++) {
		String type = variables[i].getType();
		if (getResolver(type) == null) {
			String unknown = BasicElementLabels.getJavaElementName(type);
			throw new TemplateException(Messages
					.format(JavaTemplateMessages.CodeTemplateContextType_validate_unknownvariable, unknown));
		}
		required.remove(type);
	}
	if (!required.isEmpty()) {
		String missing = BasicElementLabels.getJavaElementName(required.get(0));
		throw new TemplateException(
				Messages.format(JavaTemplateMessages.CodeTemplateContextType_validate_missingvariable, missing));
	}
	super.validateVariables(variables);
}
 

import org.eclipse.jface.text.templates.TemplateException; //导入依赖的package包/类
@Override
public TemplateBuffer evaluate(Template template) throws BadLocationException, TemplateException {
  // test that all variables are defined
  Iterator<TemplateVariableResolver> iterator = getContextType().resolvers();
  while (iterator.hasNext()) {
    TemplateVariableResolver var = iterator.next();
    if (var instanceof CodeTemplateContextType.CodeTemplateVariableResolver) {
      Assert.isNotNull(
          getVariable(var.getType()),
          "Variable " + var.getType() + "not defined"); // $NON-NLS-1$ //$NON-NLS-2$
    }
  }

  if (!canEvaluate(template)) return null;

  String pattern = changeLineDelimiter(template.getPattern(), fLineDelimiter);

  TemplateTranslator translator = new TemplateTranslator();
  TemplateBuffer buffer = translator.translate(pattern);
  getContextType().resolve(buffer, this);
  return buffer;
}
 

import org.eclipse.jface.text.templates.TemplateException; //导入依赖的package包/类
@Override
protected void validateVariables(TemplateVariable[] variables) throws TemplateException {
  ArrayList<String> required = new ArrayList<String>(5);
  String contextName = getId();
  if (NEWTYPE_CONTEXTTYPE.equals(contextName)) {
    required.add(PACKAGE_DECLARATION);
    required.add(TYPE_DECLARATION);
  }
  for (int i = 0; i < variables.length; i++) {
    String type = variables[i].getType();
    if (getResolver(type) == null) {
      String unknown = BasicElementLabels.getJavaElementName(type);
      throw new TemplateException(
          Messages.format(
              JavaTemplateMessages.CodeTemplateContextType_validate_unknownvariable, unknown));
    }
    required.remove(type);
  }
  if (!required.isEmpty()) {
    String missing = BasicElementLabels.getJavaElementName(required.get(0));
    throw new TemplateException(
        Messages.format(
            JavaTemplateMessages.CodeTemplateContextType_validate_missingvariable, missing));
  }
  super.validateVariables(variables);
}
 

import org.eclipse.jface.text.templates.TemplateException; //导入依赖的package包/类
@Override
public TemplateBuffer evaluate(Template template) throws BadLocationException, TemplateException {
  TemplateTranslator translator = new TemplateTranslator();
  TemplateBuffer buffer = translator.translate(template);

  getContextType().resolve(buffer, this);

  //		IPreferenceStore prefs= JavaPlugin.getDefault().getPreferenceStore();
  boolean useCodeFormatter =
      true; // prefs.getBoolean(PreferenceConstants.TEMPLATES_USE_CODEFORMATTER);

  IJavaProject project = getJavaProject();
  JavaFormatter formatter =
      new JavaFormatter(
          TextUtilities.getDefaultLineDelimiter(getDocument()),
          getIndentation(),
          useCodeFormatter,
          project);
  formatter.format(buffer, this);

  return buffer;
}
 

import org.eclipse.jface.text.templates.TemplateException; //导入依赖的package包/类
@Override
public String getAdditionalProposalInfo() {
    this.getContext().setReadOnly(true);
	TemplateBuffer templateBuffer;
	try {
		templateBuffer= this.getContext().evaluate(this.getTemplate());
	} 
	catch (BadLocationException | TemplateException ex) {
		String message = "<b>Error when resolving variables.</b><br>"
				+ "Nothing will be inserted<br><br>"
				+ escapeHTML(ex.getMessage());
		return message;
	}
	String info = escapeHTML(this.getTemplate().getDescription()) + 
			"<br><br><b>Inserts:</b><br>" + 
			escapeHTML(templateBuffer.getString());
	return info;
}
 

import org.eclipse.jface.text.templates.TemplateException; //导入依赖的package包/类
final void parse(List<String> params) throws TemplateException {
		for (String expression : params) {
			try {
				if (expression.trim().isEmpty()) {
					throw new TemplateException("Empty expression");
				}
				new ComplexExpression(expression.trim());
			}
			catch (RuntimeException ex) {
				throw new TemplateException("Invalid expression: " + expression + "; " + ex.getMessage(), ex);
			}
		}
//		if (messages.size() > 0) {
//			StringBuilder result = new StringBuilder();
//			for (String message : messages) {
//				result.append(message).append("\n");
//			}
//			throw new TemplateException(result.toString());
//		}
	}
 

import org.eclipse.jface.text.templates.TemplateException; //导入依赖的package包/类
ValueOrVariableExpression(String expression) throws TemplateException {
String check = expression;
if (expression.startsWith("-")) {
	check = check.substring(1).trim();
	this.sign = '-';
}
else {
	this.sign = '+';
}
if (check.isEmpty()) {
	throw new TemplateException("Invalid variable: " + expression);
}
this.isVariable = Character.isLetter(check.charAt(0));
for (int i = 0; i < check.length(); i++) {
	if (!Character.isLetterOrDigit(check.charAt(i)) ||
			(!this.isVariable && !Character.isDigit(check.charAt(i)))) {
		throw new TemplateException("Invalid value or variable: " + expression);
	}
}
if (this.isVariable) {
	this.value = check;
}
else {
	this.value = expression;
}
}
 

import org.eclipse.jface.text.templates.TemplateException; //导入依赖的package包/类
private Operator parseOperator(String partExp) throws TemplateException {
	char operator = partExp.charAt(0);
	switch (operator) {
		case '*' :
			return Operator.MULTPLY;
		case '/' : 
			return Operator.DIVIDE;
		case '%' :
			return Operator.MODULO;
		case '+' :
			return Operator.ADD;
		case '-' :
			return Operator.SUBTRACT;
		default :
			throw new TemplateException("Illegal operator: " + partExp);
	}
}
 

import org.eclipse.jface.text.templates.TemplateException; //导入依赖的package包/类
public TemplateBuffer evaluate(Template template) throws BadLocationException, TemplateException
{
	if (!canEvaluate(template))
		return null;

	try
	{
		this.template = template;

		TemplateTranslator translator = new SnippetTemplateTranslator();
		TemplateBuffer buffer = translator.translate(template);

		getContextType().resolve(buffer, this);

		return buffer;
	}
	finally
	{
		this.template = null;
	}
}
 

import org.eclipse.jface.text.templates.TemplateException; //导入依赖的package包/类
@Override
public TemplateBuffer evaluate(Template template) throws BadLocationException, TemplateException {
	// test that all variables are defined
	Iterator<TemplateVariableResolver> iterator= getContextType().resolvers();
	while (iterator.hasNext()) {
		TemplateVariableResolver var= iterator.next();
		if (var instanceof CodeTemplateContextType.CodeTemplateVariableResolver) {
			Assert.isNotNull(getVariable(var.getType()), "Variable " + var.getType() + "not defined"); //$NON-NLS-1$ //$NON-NLS-2$
		}
	}

	if (!canEvaluate(template))
		return null;

	String pattern= changeLineDelimiter(template.getPattern(), fLineDelimiter);

	TemplateTranslator translator= new TemplateTranslator();
	TemplateBuffer buffer= translator.translate(pattern);
	getContextType().resolve(buffer, this);
	return buffer;
}
 

import org.eclipse.jface.text.templates.TemplateException; //导入依赖的package包/类
@Override
protected void validateVariables(TemplateVariable[] variables) throws TemplateException {
	ArrayList<String> required=  new ArrayList<String>(5);
	String contextName= getId();
	if (NEWTYPE_CONTEXTTYPE.equals(contextName)) {
		required.add(PACKAGE_DECLARATION);
		required.add(TYPE_DECLARATION);
	}
	for (int i= 0; i < variables.length; i++) {
		String type= variables[i].getType();
		if (getResolver(type) == null) {
			String unknown= BasicElementLabels.getJavaElementName(type);
			throw new TemplateException(Messages.format(JavaTemplateMessages.CodeTemplateContextType_validate_unknownvariable, unknown));
		}
		required.remove(type);
	}
	if (!required.isEmpty()) {
		String missing= BasicElementLabels.getJavaElementName(required.get(0));
		throw new TemplateException(Messages.format(JavaTemplateMessages.CodeTemplateContextType_validate_missingvariable, missing));
	}
	super.validateVariables(variables);
}
 

import org.eclipse.jface.text.templates.TemplateException; //导入依赖的package包/类
/**
 * Evaluates a 'java' template in the context of a compilation unit
 *
 * @param template the template to be evaluated
 * @param compilationUnit the compilation unit in which to evaluate the template
 * @param position the position inside the compilation unit for which to evaluate the template
 * @return the evaluated template
 * @throws CoreException in case the template is of an unknown context type
 * @throws BadLocationException in case the position is invalid in the compilation unit
 * @throws TemplateException in case the evaluation fails
 */
public static String evaluateTemplate(Template template, ICompilationUnit compilationUnit, int position) throws CoreException, BadLocationException, TemplateException {

	TemplateContextType contextType= JavaPlugin.getDefault().getTemplateContextRegistry().getContextType(template.getContextTypeId());
	if (!(contextType instanceof CompilationUnitContextType))
		throw new CoreException(new Status(IStatus.ERROR, JavaUI.ID_PLUGIN, IStatus.ERROR, JavaTemplateMessages.JavaContext_error_message, null));

	IDocument document= new Document();
	if (compilationUnit != null && compilationUnit.exists())
		document.set(compilationUnit.getSource());

	CompilationUnitContext context= ((CompilationUnitContextType) contextType).createContext(document, position, 0, compilationUnit);
	context.setForceEvaluation(true);

	TemplateBuffer buffer= context.evaluate(template);
	if (buffer == null)
		return null;
	return buffer.getString();
}
 

import org.eclipse.jface.text.templates.TemplateException; //导入依赖的package包/类
@Override
public TemplateBuffer evaluate(Template template) throws BadLocationException, TemplateException {
	TemplateTranslator translator= new TemplateTranslator();
	TemplateBuffer buffer= translator.translate(template);

	getContextType().resolve(buffer, this);

	IPreferenceStore prefs= JavaPlugin.getDefault().getPreferenceStore();
	boolean useCodeFormatter= prefs.getBoolean(PreferenceConstants.TEMPLATES_USE_CODEFORMATTER);

	IJavaProject project= getJavaProject();
	JavaFormatter formatter= new JavaFormatter(TextUtilities.getDefaultLineDelimiter(getDocument()), getIndentation(), useCodeFormatter, project);
	formatter.format(buffer, this);

	return buffer;
}
 

import org.eclipse.jface.text.templates.TemplateException; //导入依赖的package包/类
/**
 * Returns template string to insert.
 * 
 * @param context the context to use when rendering the template
 * @return String to insert or null if none is to be inserted
 */
public final String getTemplateString(final TemplateContext context) {
    String templateString = null;

    if (useTemplateButton.getSelection()) {
        Template template = getSelectedTemplate();
        if (template != null) {
            try {
                TemplateBuffer buffer = context.evaluate(template);
                templateString = buffer.getString();
            } catch (BadLocationException | TemplateException e) {
                final String msg = "Unable to create template for new component";
                final IStatus status = new Status(IStatus.WARNING, ForceIdeEditorsPlugin.PLUGIN_ID, msg, e);
                logger().log(status);
            }
        }
    }

    return templateString;
}