a73169ac02eabce59a257b9142e006af316958f8
[idea/community.git] / java / debugger / impl / src / com / intellij / debugger / engine / evaluation / TextWithImportsImpl.java
1 /*
2  * Copyright 2000-2015 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.intellij.debugger.engine.evaluation;
17
18 import com.intellij.debugger.ui.DebuggerEditorImpl;
19 import com.intellij.openapi.fileTypes.FileType;
20 import com.intellij.openapi.fileTypes.FileTypeManager;
21 import com.intellij.openapi.fileTypes.StdFileTypes;
22 import com.intellij.openapi.util.Comparing;
23 import com.intellij.openapi.util.Trinity;
24 import com.intellij.openapi.util.text.StringUtil;
25 import com.intellij.psi.*;
26 import com.intellij.xdebugger.XExpression;
27 import com.intellij.xdebugger.evaluation.EvaluationMode;
28 import com.intellij.xdebugger.impl.breakpoints.XExpressionImpl;
29 import com.intellij.xdebugger.impl.ui.XDebuggerEditorBase;
30 import org.jetbrains.annotations.NotNull;
31 import org.jetbrains.annotations.Nullable;
32
33 public final class TextWithImportsImpl implements TextWithImports{
34
35   private final CodeFragmentKind myKind;
36   private String myText;
37   private final FileType myFileType;
38   private final String myImports;
39
40   public TextWithImportsImpl(@NotNull PsiElement expression) {
41     myKind = CodeFragmentKind.EXPRESSION;
42     final String text = expression.getText();
43     PsiFile containingFile = expression.getContainingFile();
44     if(containingFile instanceof PsiExpressionCodeFragment) {
45       myText = text;
46       myImports = ((JavaCodeFragment)containingFile).importsToString();
47       myFileType = StdFileTypes.JAVA;
48     }
49     else {
50       Trinity<String, String, FileType> trinity = parseExternalForm(text);
51       myText = trinity.first;
52       myImports = trinity.second;
53       myFileType = trinity.third;
54     }
55   }
56
57   public TextWithImportsImpl (CodeFragmentKind kind, @NotNull String text, @NotNull String imports, @Nullable FileType fileType) {
58     myKind = kind;
59     myText = text;
60     myImports = imports;
61     myFileType = fileType;
62   }
63
64   public TextWithImportsImpl(CodeFragmentKind kind, @NotNull String text) {
65     myKind = kind;
66     Trinity<String, String, FileType> trinity = parseExternalForm(text);
67     myText = trinity.first;
68     myImports = trinity.second;
69     myFileType = trinity.third;
70   }
71
72   private static Trinity<String, String, FileType> parseExternalForm(String s) {
73     String[] split = s.split(String.valueOf(DebuggerEditorImpl.SEPARATOR));
74     return Trinity.create(split[0], split.length > 1 ? split[1] : "", split.length > 2 ? FileTypeManager.getInstance().getStdFileType(split[2]) : null);
75   }
76
77   @Override
78   public CodeFragmentKind getKind() {
79     return myKind;
80   }
81
82   @Override
83   public String getText() {
84     return myText;
85   }
86
87   @Override
88   public @NotNull String getImports() {
89     return myImports;
90   }
91
92   public boolean equals(Object object) {
93     if(!(object instanceof TextWithImportsImpl)) {
94       return false;
95     }
96     TextWithImportsImpl item = ((TextWithImportsImpl)object);
97     return Comparing.equal(item.myText, myText) && Comparing.equal(item.myImports, myImports);
98   }
99
100   public String toString() {
101     return getText();
102   }
103
104   @Override
105   public String toExternalForm() {
106     String result = myText;
107     if (StringUtil.isNotEmpty(myImports) || myFileType != null) {
108       result += DebuggerEditorImpl.SEPARATOR + myImports;
109     }
110     if (myFileType != null) {
111       result += DebuggerEditorImpl.SEPARATOR + myFileType.getName();
112     }
113     return result;
114   }
115
116   public int hashCode() {
117     return myText.hashCode();
118   }
119
120   @Override
121   public boolean isEmpty() {
122     return StringUtil.isEmptyOrSpaces(getText());
123   }
124
125   @Override
126   public void setText(String newText) {
127     myText = newText;
128   }
129
130   @Override
131   public FileType getFileType() {
132     return myFileType;
133   }
134
135   @Nullable
136   public static XExpression toXExpression(@Nullable TextWithImports text) {
137     if (text != null && !text.getText().isEmpty()) {
138       return new XExpressionImpl(text.getText(),
139                                  XDebuggerEditorBase.getFileTypeLanguage(text.getFileType()),
140                                  StringUtil.nullize(text.getImports()),
141                                  getMode(text.getKind()));
142     }
143     return null;
144   }
145
146   private static EvaluationMode getMode(CodeFragmentKind kind) {
147     switch (kind) {
148       case EXPRESSION: return EvaluationMode.EXPRESSION;
149       case CODE_BLOCK: return EvaluationMode.CODE_FRAGMENT;
150     }
151     throw new IllegalStateException("Unknown kind " + kind);
152   }
153
154   private static CodeFragmentKind getKind(EvaluationMode mode) {
155     switch (mode) {
156       case EXPRESSION: return CodeFragmentKind.EXPRESSION;
157       case CODE_FRAGMENT: return CodeFragmentKind.CODE_BLOCK;
158     }
159     throw new IllegalStateException("Unknown mode " + mode);
160   }
161
162   public static TextWithImports fromXExpression(@Nullable XExpression expression) {
163     if (expression == null) return null;
164
165     if (expression.getCustomInfo() == null && expression.getLanguage() == null) {
166       return new TextWithImportsImpl(getKind(expression.getMode()), expression.getExpression());
167     }
168     else {
169       return new TextWithImportsImpl(getKind(expression.getMode()),
170                                      expression.getExpression(),
171                                      StringUtil.notNullize(expression.getCustomInfo()),
172                                      expression.getLanguage() != null ? expression.getLanguage().getAssociatedFileType() : null);
173     }
174   }
175 }