lang-impl/src/com/intellij/codeInsight/template/impl/TemplateImpl.java

   1 package com.intellij.codeInsight.template.impl;
   2
   3 import com.intellij.codeInsight.template.Expression;
   4 import com.intellij.codeInsight.template.Template;
   5 import com.intellij.openapi.util.text.StringUtil;
   6 import com.intellij.psi.tree.IElementType;
   7 import org.jetbrains.annotations.NonNls;
   8
   9 import java.util.ArrayList;
  10 import java.util.Arrays;
  11 import java.util.HashSet;
  12 import java.util.Set;
  13
  14 /**
  15  *
  16  */
  17 public class TemplateImpl implements Template {
  18   private String myKey;
  19   private String myString = null;
  20   private String myDescription;
  21   private String myGroupName;
  22   private char myShortcutChar = TemplateSettings.DEFAULT_CHAR;
  23   private ArrayList<Variable> myVariables = new ArrayList<Variable>();
  24   private ArrayList<Segment> mySegments = null;
  25   private String myTemplateText = null;
  26   private String myId;
  27
  28   public boolean equals(Object o) {
  29     if (this == o) return true;
  30     if (!(o instanceof TemplateImpl)) return false;
  31
  32     final TemplateImpl template = (TemplateImpl) o;
  33     if (myId != null && template.myId != null && myId.equals(template.myId)) return true;
  34
  35     if (isToReformat != template.isToReformat) return false;
  36     if (isToShortenLongNames != template.isToShortenLongNames) return false;
  37     if (myShortcutChar != template.myShortcutChar) return false;
  38     if (myDescription != null ? !myDescription.equals(template.myDescription) : template.myDescription != null) return false;
  39     if (myGroupName != null ? !myGroupName.equals(template.myGroupName) : template.myGroupName != null) return false;
  40     if (myKey != null ? !myKey.equals(template.myKey) : template.myKey != null) return false;
  41     if (myString != null ? !myString.equals(template.myString) : template.myString != null) return false;
  42     if (myTemplateText != null ? !myTemplateText.equals(template.myTemplateText) : template.myTemplateText != null) return false;
  43
  44     if (myVariables == null && template.myVariables == null) return true;
  45     if (myVariables == null || template.myVariables == null) return false;
  46     if (myVariables.size() != template.myVariables.size()) return false;
  47     for (Variable variable : myVariables) {
  48       if (template.myVariables.indexOf(variable) < 0) return false;
  49     }
  50
  51     return true;
  52   }
  53
  54   public int hashCode() {
  55     if (myId != null) {
  56       return myId.hashCode();
  57     }
  58     int result;
  59     result = myKey.hashCode();
  60     result = 29 * result + (myString == null ? 0 : myString.hashCode());
  61     result = 29 * result + myGroupName.hashCode();
  62     return result;
  63   }
  64
  65   private boolean isToReformat = false;
  66   private boolean isToShortenLongNames = true;
  67   private boolean toParseSegments = true;
  68   private TemplateContext myTemplateContext = new TemplateContext();
  69
  70   public static final @NonNls String END = "END";
  71   public static final @NonNls String SELECTION = "SELECTION";
  72   public static final @NonNls String SELECTION_START = "SELECTION_START";
  73   public static final @NonNls String SELECTION_END = "SELECTION_END";
  74
  75   public static final Set<String> INTERNAL_VARS_SET = new HashSet<String>(Arrays.asList(
  76       END, SELECTION, SELECTION_START, SELECTION_END));
  77
  78   private boolean isDeactivated = false;
  79
  80   public boolean isInline() {
  81     return myIsInline;
  82   }
  83
  84   private boolean isToIndent = true;
  85
  86
  87   public void setInline(boolean isInline) {
  88     myIsInline = isInline;
  89   }
  90
  91   private boolean myIsInline = false;
  92
  93
  94
  95   public TemplateImpl(String key, String group) {
  96     this(key, null, group);
  97     toParseSegments = false;
  98     myTemplateText = "";
  99     mySegments = new ArrayList<Segment>();
 100   }
 101
 102   public TemplateImpl(String key, String string, String group) {
 103     myKey = key;
 104     myString = string;
 105     myGroupName = group;
 106   }
 107
 108
 109   public void addTextSegment(String text) {
 110     text = StringUtil.convertLineSeparators(text, "\n");
 111     myTemplateText += text;
 112   }
 113
 114   public void addVariableSegment (String name) {
 115     mySegments.add(new Segment(name, myTemplateText.length()));
 116   }
 117
 118   public void addVariable(String name, Expression expression, Expression defaultValueExpression, boolean isAlwaysStopAt) {
 119     if (mySegments != null) {
 120       Segment segment = new Segment(name, myTemplateText.length());
 121       mySegments.add(segment);
 122     }
 123     Variable variable = new Variable(name, expression, defaultValueExpression, isAlwaysStopAt);
 124     myVariables.add(variable);
 125   }
 126
 127   public void addEndVariable() {
 128     Segment segment = new Segment(END, myTemplateText.length());
 129     mySegments.add(segment);
 130   }
 131
 132   public void addSelectionStartVariable() {
 133     Segment segment = new Segment(SELECTION_START, myTemplateText.length());
 134     mySegments.add(segment);
 135   }
 136
 137   public void addSelectionEndVariable() {
 138     Segment segment = new Segment(SELECTION_END, myTemplateText.length());
 139     mySegments.add(segment);
 140   }
 141
 142   public String getId() {
 143     return myId;
 144   }
 145
 146   public TemplateImpl copy() {
 147     TemplateImpl template = new TemplateImpl(myKey, myString, myGroupName);
 148     template.myId = myId;
 149     template.myDescription = myDescription;
 150     template.myShortcutChar = myShortcutChar;
 151     template.isToReformat = isToReformat;
 152     template.isToShortenLongNames = isToShortenLongNames;
 153     template.myIsInline = myIsInline;
 154     template.myTemplateContext = (TemplateContext)myTemplateContext.clone();
 155     template.isDeactivated = isDeactivated;
 156     for (Variable variable : myVariables) {
 157       template.addVariable(variable.getName(), variable.getExpressionString(), variable.getDefaultValueString(), variable.isAlwaysStopAt());
 158     }
 159     return template;
 160   }
 161
 162   public boolean isToReformat() {
 163     return isToReformat;
 164   }
 165
 166   public void setToReformat(boolean toReformat) {
 167     isToReformat = toReformat;
 168   }
 169
 170   public void setToIndent(boolean toIndent) {
 171     isToIndent = toIndent;
 172   }
 173
 174   public boolean isToIndent() {
 175     return isToIndent;
 176   }
 177
 178   public boolean isToShortenLongNames() {
 179     return isToShortenLongNames;
 180   }
 181
 182   public void setToShortenLongNames(boolean toShortenLongNames) {
 183     isToShortenLongNames = toShortenLongNames;
 184   }
 185
 186   public void setDeactivated(boolean isDeactivated) {
 187     this.isDeactivated = isDeactivated;
 188   }
 189
 190   public boolean isDeactivated() {
 191     return isDeactivated;
 192   }
 193
 194   public TemplateContext getTemplateContext() {
 195     return myTemplateContext;
 196   }
 197
 198   public int getEndSegmentNumber() {
 199     return getVariableSegmentNumber(END);
 200   }
 201
 202   public int getSelectionStartSegmentNumber() {
 203     return getVariableSegmentNumber(SELECTION_START);
 204   }
 205
 206   public int getSelectionEndSegmentNumber() {
 207     return getVariableSegmentNumber(SELECTION_END);
 208   }
 209
 210   public int getVariableSegmentNumber(String variableName) {
 211     parseSegments();
 212     for (int i = 0; i < mySegments.size(); i++) {
 213       Segment segment = mySegments.get(i);
 214       if (segment.name.equals(variableName)) {
 215         return i;
 216       }
 217     }
 218     return -1;
 219   }
 220
 221   public String getTemplateText() {
 222     parseSegments();
 223     return myTemplateText;
 224   }
 225
 226   public String getSegmentName(int i) {
 227     parseSegments();
 228     return mySegments.get(i).name;
 229   }
 230
 231   public int getSegmentOffset(int i) {
 232     parseSegments();
 233     return mySegments.get(i).offset;
 234   }
 235
 236   public int getSegmentsCount() {
 237     parseSegments();
 238     return mySegments.size();
 239   }
 240
 241   public void parseSegments() {
 242     if(!toParseSegments) {
 243       return;
 244     }
 245     if(mySegments != null) {
 246       return;
 247     }
 248
 249     if (myString == null) myString = "";
 250     myString = StringUtil.convertLineSeparators(myString, "\n");
 251     mySegments = new ArrayList<Segment>();
 252     StringBuffer buffer = new StringBuffer("");
 253     TemplateTextLexer lexer = new TemplateTextLexer();
 254     lexer.start(myString,0,myString.length(),0);
 255
 256     while(true){
 257       IElementType tokenType = lexer.getTokenType();
 258       if (tokenType == null) break;
 259       int start = lexer.getTokenStart();
 260       int end = lexer.getTokenEnd();
 261       String token = myString.substring(start, end);
 262       if (tokenType == TemplateTokenType.VARIABLE){
 263         String name = token.substring(1, token.length() - 1);
 264         Segment segment = new Segment(name, buffer.length());
 265         mySegments.add(segment);
 266       }
 267       else if (tokenType == TemplateTokenType.ESCAPE_DOLLAR){
 268         buffer.append("$");
 269       }
 270       else{
 271         buffer.append(token);
 272       }
 273       lexer.advance();
 274     }
 275     myTemplateText = buffer.toString();
 276   }
 277
 278   public void removeAllParsed() {
 279     myVariables.clear();
 280     mySegments = null;
 281   }
 282
 283   public void addVariable(String name, String expression, String defaultValue, boolean isAlwaysStopAt) {
 284     Variable variable = new Variable(name, expression, defaultValue, isAlwaysStopAt);
 285     myVariables.add(variable);
 286   }
 287
 288   public int getVariableCount() {
 289     return myVariables.size();
 290   }
 291
 292   public String getVariableNameAt(int i) {
 293     return myVariables.get(i).getName();
 294   }
 295
 296   public String getExpressionStringAt(int i) {
 297     return myVariables.get(i).getExpressionString();
 298   }
 299
 300   public Expression getExpressionAt(int i) {
 301     return myVariables.get(i).getExpression();
 302   }
 303
 304   public String getDefaultValueStringAt(int i) {
 305     return myVariables.get(i).getDefaultValueString();
 306   }
 307
 308   public Expression getDefaultValueAt(int i) {
 309     return myVariables.get(i).getDefaultValueExpression();
 310   }
 311
 312   public boolean isAlwaysStopAt(int i) {
 313     return myVariables.get(i).isAlwaysStopAt();
 314   }
 315
 316   public String getKey() {
 317     return myKey;
 318   }
 319
 320   public void setKey(String key) {
 321     myKey = key;
 322   }
 323
 324   public String getString() {
 325     parseSegments();
 326     return myString;
 327   }
 328
 329   public void setString(String string) {
 330     myString = string;
 331   }
 332
 333   public String getDescription() {
 334     return myDescription;
 335   }
 336
 337   public void setDescription(String description) {
 338     myDescription = description;
 339   }
 340
 341   public char getShortcutChar() {
 342     return myShortcutChar;
 343   }
 344
 345   public void setShortcutChar(char shortcutChar) {
 346     myShortcutChar = shortcutChar;
 347   }
 348
 349   public String getGroupName() {
 350     return myGroupName;
 351   }
 352
 353   public void setGroupName(String groupName) {
 354     myGroupName = groupName;
 355   }
 356
 357   public boolean isSelectionTemplate() {
 358     for (Variable v : myVariables) {
 359       if (v.getName().equals(SELECTION)) return true;
 360     }
 361
 362     return false;
 363   }
 364
 365   public void setId(final String id) {
 366     myId = id;
 367   }
 368
 369   private static class Segment {
 370     public String name;
 371     public int offset;
 372
 373     public Segment(String name, int offset) {
 374       this.name = name;
 375       this.offset = offset;
 376     }
 377   }
 378 }