001 /*
002 * Copyright 2010-2015 JetBrains s.r.o.
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016
017 package org.jetbrains.kotlin.cli.common.messages;
018
019 import com.google.common.collect.LinkedHashMultimap;
020 import com.google.common.collect.Multimap;
021 import org.jetbrains.annotations.NotNull;
022
023 import java.util.*;
024
025 public class GroupingMessageCollector implements MessageCollector {
026
027 private final MessageCollector delegate;
028
029 // File path (nullable) -> message
030 private final Multimap<String, Message> groupedMessages = LinkedHashMultimap.create();
031
032 public GroupingMessageCollector(@NotNull MessageCollector delegate) {
033 this.delegate = delegate;
034 }
035
036 @Override
037 public void report(
038 @NotNull CompilerMessageSeverity severity,
039 @NotNull String message,
040 @NotNull CompilerMessageLocation location
041 ) {
042 if (CompilerMessageSeverity.VERBOSE.contains(severity)) {
043 delegate.report(severity, message, location);
044 }
045 else {
046 groupedMessages.put(location.getPath(), new Message(severity, message, location));
047 }
048 }
049
050 public void flush() {
051 boolean hasError = false;
052
053 Collection<String> keys = sortedKeys();
054 for (String path : keys) {
055 for (Message message : groupedMessages.get(path)) {
056 hasError |= CompilerMessageSeverity.ERRORS.contains(message.severity);
057 }
058 }
059
060 for (String path : keys) {
061 for (Message message : groupedMessages.get(path)) {
062 if (!hasError || CompilerMessageSeverity.ERRORS.contains(message.severity)) {
063 delegate.report(message.severity, message.message, message.location);
064 }
065 }
066 }
067
068 groupedMessages.clear();
069 }
070
071 @NotNull
072 private Collection<String> sortedKeys() {
073 List<String> sortedKeys = new ArrayList<String>(groupedMessages.keySet());
074 // ensure that messages with no location i.e. perf, incomplete hierarchy are always reported first
075 Collections.sort(sortedKeys, new Comparator<String>() {
076 @Override
077 public int compare(String o1, String o2) {
078 if (o1 == o2) return 0;
079 if (o1 == null) return -1;
080 if (o2 == null) return 1;
081 return o1.compareTo(o2);
082 }
083 });
084 return sortedKeys;
085 }
086
087 private static class Message {
088 private final CompilerMessageSeverity severity;
089 private final String message;
090 private final CompilerMessageLocation location;
091
092 private Message(@NotNull CompilerMessageSeverity severity, @NotNull String message, @NotNull CompilerMessageLocation location) {
093 this.severity = severity;
094 this.message = message;
095 this.location = location;
096 }
097
098 @Override
099 public boolean equals(Object o) {
100 if (this == o) return true;
101 if (o == null || getClass() != o.getClass()) return false;
102
103 Message message1 = (Message) o;
104
105 if (!location.equals(message1.location)) return false;
106 if (!message.equals(message1.message)) return false;
107 if (severity != message1.severity) return false;
108
109 return true;
110 }
111
112 @Override
113 public int hashCode() {
114 int result = severity.hashCode();
115 result = 31 * result + message.hashCode();
116 result = 31 * result + location.hashCode();
117 return result;
118 }
119 }
120 }