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 clear() {
038            groupedMessages.clear();
039        }
040    
041        @Override
042        public void report(
043                @NotNull CompilerMessageSeverity severity,
044                @NotNull String message,
045                @NotNull CompilerMessageLocation location
046        ) {
047            if (CompilerMessageSeverity.VERBOSE.contains(severity)) {
048                delegate.report(severity, message, location);
049            }
050            else {
051                groupedMessages.put(location.getPath(), new Message(severity, message, location));
052            }
053        }
054    
055        @Override
056        public boolean hasErrors() {
057            for (Map.Entry<String, Message> entry : groupedMessages.entries()) {
058                if (entry.getValue().severity.isError()) {
059                    return true;
060                }
061            }
062    
063            return false;
064        }
065    
066        public void flush() {
067            boolean hasErrors = hasErrors();
068    
069            for (String path : sortedKeys()) {
070                for (Message message : groupedMessages.get(path)) {
071                    if (!hasErrors || message.severity.isError()) {
072                        delegate.report(message.severity, message.message, message.location);
073                    }
074                }
075            }
076    
077            groupedMessages.clear();
078        }
079    
080        @NotNull
081        private Collection<String> sortedKeys() {
082            List<String> sortedKeys = new ArrayList<String>(groupedMessages.keySet());
083            // ensure that messages with no location i.e. perf, incomplete hierarchy are always reported first
084            Collections.sort(sortedKeys, new Comparator<String>() {
085                @Override
086                public int compare(String o1, String o2) {
087                    if (o1 == o2) return 0;
088                    if (o1 == null) return -1;
089                    if (o2 == null) return 1;
090                    return o1.compareTo(o2);
091                }
092            });
093            return sortedKeys;
094        }
095    
096        private static class Message {
097            private final CompilerMessageSeverity severity;
098            private final String message;
099            private final CompilerMessageLocation location;
100    
101            private Message(@NotNull CompilerMessageSeverity severity, @NotNull String message, @NotNull CompilerMessageLocation location) {
102                this.severity = severity;
103                this.message = message;
104                this.location = location;
105            }
106    
107            @Override
108            public boolean equals(Object o) {
109                if (this == o) return true;
110                if (o == null || getClass() != o.getClass()) return false;
111    
112                Message message1 = (Message) o;
113    
114                if (!location.equals(message1.location)) return false;
115                if (!message.equals(message1.message)) return false;
116                if (severity != message1.severity) return false;
117    
118                return true;
119            }
120    
121            @Override
122            public int hashCode() {
123                int result = severity.hashCode();
124                result = 31 * result + message.hashCode();
125                result = 31 * result + location.hashCode();
126                return result;
127            }
128        }
129    }