df872b1db4c9deceeaa61d73120ade2dbe29188e
[idea/community.git] / jps / jps-builders / src / org / jetbrains / jps / incremental / messages / CompilerMessage.java
1 /*
2  * Copyright 2000-2012 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 org.jetbrains.jps.incremental.messages;
17
18 import com.intellij.openapi.util.text.StringUtil;
19 import com.intellij.util.Function;
20 import com.intellij.util.containers.ContainerUtil;
21 import org.jetbrains.annotations.NotNull;
22 import org.jetbrains.annotations.Nullable;
23
24 import java.io.ByteArrayOutputStream;
25 import java.io.File;
26 import java.io.PrintStream;
27 import java.util.Collection;
28 import java.util.Collections;
29
30 /**
31  * @author Eugene Zhuravlev
32  *         Date: 9/29/11
33  */
34 public class CompilerMessage extends BuildMessage {
35
36   private final String myCompilerName;
37   private final long myProblemBeginOffset;
38   private final long myProblemEndOffset;
39   private final long myProblemLocationOffset;
40   private final Collection<String> mySourcePaths;
41   private final long myLine;
42   private final long myColumn;
43
44   public CompilerMessage(@NotNull String compilerName, @NotNull Throwable internalError) {
45     this(compilerName, Kind.ERROR, getTextFromThrowable(internalError));
46   }
47
48   public CompilerMessage(@NotNull String compilerName, Kind kind, String messageText) {
49     this(compilerName, kind, messageText, (String)null, -1L, -1L, -1L, -1L, -1L);
50   }
51
52   public CompilerMessage(@NotNull String compilerName, String messageText, Collection<String> sourcePaths, Kind kind) {
53     this(compilerName, kind, messageText, sourcePaths, -1L, -1L, -1L, -1L, -1L);
54   }
55
56   public CompilerMessage(@NotNull String compilerName, Kind kind, String messageText, String sourcePath) {
57     this(compilerName, messageText, Collections.singleton(sourcePath), kind);
58   }
59
60   public CompilerMessage(@NotNull String compilerName, Kind kind, String messageText,
61                          @NotNull Collection<String> sourcePaths,
62                          long problemBeginOffset,
63                          long problemEndOffset,
64                          long problemLocationOffset,
65                          long locationLine,
66                          long locationColumn) {
67     super(messageText, kind);
68     myCompilerName = compilerName;
69     myProblemBeginOffset = problemBeginOffset;
70     myProblemEndOffset = problemEndOffset;
71     myProblemLocationOffset = problemLocationOffset;
72     mySourcePaths = ContainerUtil.map(sourcePaths, new Function<String, String>() {
73       @Override
74       public String fun(String s) {
75         return s.replace(File.separatorChar, '/');
76       }
77     });
78     myLine = locationLine;
79     myColumn = locationColumn;
80   }
81
82   public CompilerMessage(@NotNull String compilerName, Kind kind, String messageText,
83                          @Nullable String sourcePath,
84                          long problemBeginOffset,
85                          long problemEndOffset,
86                          long problemLocationOffset,
87                          long locationLine,
88                          long locationColumn) {
89     this(compilerName,
90          kind,
91          messageText,
92          sourcePath == null ? Collections.<String>emptyList() : Collections.singleton(sourcePath),
93          problemBeginOffset,
94          problemEndOffset,
95          problemLocationOffset,
96          locationLine,
97          locationColumn);
98   }
99
100   @NotNull
101   public String getCompilerName() {
102     return myCompilerName;
103   }
104
105   @Nullable
106   public String getSourcePath() {
107     return mySourcePaths.size() == 1 ? ContainerUtil.getFirstItem(mySourcePaths) : null;
108   }
109
110   public long getLine() {
111     return myLine;
112   }
113
114   public long getColumn() {
115     return myColumn;
116   }
117
118   public long getProblemBeginOffset() {
119     return myProblemBeginOffset;
120   }
121
122   public long getProblemEndOffset() {
123     return myProblemEndOffset;
124   }
125
126   public long getProblemLocationOffset() {
127     return myProblemLocationOffset;
128   }
129
130   public String toString() {
131     final StringBuilder builder = new StringBuilder();
132     builder.append(getCompilerName()).append(":").append(getKind().name()).append(":").append(super.toString());
133     String result;
134     if (mySourcePaths.isEmpty()) {
135       result = null;
136     }
137     else if (mySourcePaths.size() == 1) {
138       result = ContainerUtil.getFirstItem(mySourcePaths);
139     } else {
140       result = mySourcePaths.toString();
141     }
142     final String path = result;
143     if (path != null) {
144       builder.append("; file: ").append(path);
145       final long line = getLine();
146       final long column = getColumn();
147       if (line >= 0 && column >= 0) {
148         builder.append(" at (").append(line).append(":").append(column).append(")");
149       }
150     }
151     return builder.toString();
152   }
153
154   public static String getTextFromThrowable(Throwable internalError) {
155     StringBuilder text = new StringBuilder();
156     text.append("Error: ");
157     final String msg = internalError.getMessage();
158     if (!StringUtil.isEmptyOrSpaces(msg)) {
159       text.append(msg);
160     }
161     else {
162       text.append(internalError.getClass().getName());
163     }
164     text.append("\n");
165
166     final ByteArrayOutputStream out = new ByteArrayOutputStream();
167     internalError.printStackTrace(new PrintStream(out));
168     text.append(out.toString());
169
170     return text.toString();
171   }
172
173 }