001 /*
002 * SonarQube, open source software quality management tool.
003 * Copyright (C) 2008-2014 SonarSource
004 * mailto:contact AT sonarsource DOT com
005 *
006 * SonarQube is free software; you can redistribute it and/or
007 * modify it under the terms of the GNU Lesser General Public
008 * License as published by the Free Software Foundation; either
009 * version 3 of the License, or (at your option) any later version.
010 *
011 * SonarQube is distributed in the hope that it will be useful,
012 * but WITHOUT ANY WARRANTY; without even the implied warranty of
013 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014 * Lesser General Public License for more details.
015 *
016 * You should have received a copy of the GNU Lesser General Public License
017 * along with this program; if not, write to the Free Software Foundation,
018 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
019 */
020 package org.sonar.api.measures;
021
022 import org.sonar.api.rules.Rule;
023 import org.sonar.api.technicaldebt.batch.Characteristic;
024 import org.sonar.api.technicaldebt.batch.Requirement;
025
026 import java.util.ArrayList;
027 import java.util.Collection;
028 import java.util.List;
029
030 /**
031 * @since 1.10
032 */
033 public final class MeasuresFilters {
034
035 private MeasuresFilters() {
036 }
037
038 public static MeasuresFilter<Collection<Measure>> all() {
039 return new MeasuresFilter<Collection<Measure>>() {
040 public Collection<Measure> filter(Collection<Measure> measures) {
041 return measures;
042 }
043 };
044 }
045
046 public static MeasuresFilter<Measure> metric(final Metric metric) {
047 return metric(metric.getKey());
048 }
049
050 public static MeasuresFilter<Measure> metric(final String metricKey) {
051 return new MetricFilter<Measure>(metricKey) {
052
053 public Measure filter(Collection<Measure> measures) {
054 if (measures == null) {
055 return null;
056 }
057 for (Measure measure : measures) {
058 if (measure.getClass().equals(Measure.class) &&
059 measure.getMetricKey().equals(metricKey) &&
060 measure.getCharacteristic() == null &&
061 measure.getPersonId() == null) {
062 return measure;
063 }
064 }
065 return null;
066 }
067 };
068 }
069
070 public static MeasuresFilter<Measure> characteristic(final Metric metric, final Characteristic characteristic) {
071 return new MetricFilter<Measure>(metric) {
072
073 public Measure filter(Collection<Measure> measures) {
074 if (measures == null) {
075 return null;
076 }
077 for (Measure measure : measures) {
078 if (measure.getClass().equals(Measure.class) &&
079 measure.getMetric().equals(metric) &&
080 measure.getPersonId() == null &&
081 isSameCharacteristic(measure, characteristic)) {
082 return measure;
083 }
084 }
085 return null;
086 }
087 };
088 }
089
090 private static boolean isSameCharacteristic(Measure measure, final Characteristic characteristic) {
091 Characteristic measureCharacteristic = measure.getCharacteristic();
092 return measureCharacteristic != null &&
093 measureCharacteristic.equals(characteristic);
094 }
095
096 /**
097 * @deprecated since 4.3
098 */
099 @Deprecated
100 public static MeasuresFilter<Measure> requirement(final Metric metric, final Requirement requirement) {
101 return new MetricFilter<Measure>(metric) {
102
103 public Measure filter(Collection<Measure> measures) {
104 if (measures == null) {
105 return null;
106 }
107 for (Measure measure : measures) {
108 if (measure.getClass().equals(Measure.class) &&
109 measure.getMetric().equals(metric) &&
110 measure.getPersonId() == null &&
111 isSameRequirement(measure, requirement)) {
112 return measure;
113 }
114 }
115 return null;
116 }
117 };
118 }
119
120 private static boolean isSameRequirement(Measure measure, final Requirement requirement) {
121 Requirement measureRequirement = measure.getRequirement();
122 return measureRequirement != null &&
123 measureRequirement.equals(requirement);
124 }
125
126 /**
127 * @since 2.0
128 */
129 public static MeasuresFilter<Measure> measure(final Measure measure) {
130 return new MeasuresFilter<Measure>() {
131 public Measure filter(Collection<Measure> measures) {
132 if (measures == null) {
133 return null;
134 }
135 for (Measure m : measures) {
136 if (m.equals(measure)) {
137 return m;
138 }
139 }
140 return null;
141 }
142 };
143 }
144
145 public static MeasuresFilter<RuleMeasure> rule(final Metric metric, final Rule rule) {
146 return new RuleFilter(metric, rule);
147 }
148
149 public static MeasuresFilter<Collection<RuleMeasure>> rules(final Metric metric) {
150 return new MetricFilter<Collection<RuleMeasure>>(metric) {
151
152 private boolean apply(Measure measure) {
153 return measure instanceof RuleMeasure && metric.equals(measure.getMetric())
154 && measure.getPersonId() == null && ((RuleMeasure) measure).getRule() != null;
155 }
156
157 public Collection<RuleMeasure> filter(Collection<Measure> measures) {
158 if (measures == null) {
159 return null;
160 }
161 List<RuleMeasure> result = new ArrayList<RuleMeasure>();
162 for (Measure measure : measures) {
163 if (apply(measure)) {
164 result.add((RuleMeasure) measure);
165 }
166 }
167 return result;
168 }
169 };
170 }
171
172 /**
173 * Used for internal optimizations.
174 */
175 public abstract static class MetricFilter<M> implements MeasuresFilter<M> {
176 private final String metricKey;
177
178 protected MetricFilter(Metric metric) {
179 this.metricKey = metric.getKey();
180 }
181
182 protected MetricFilter(String metricKey) {
183 this.metricKey = metricKey;
184 }
185
186 public String filterOnMetricKey() {
187 return metricKey;
188 }
189 }
190
191 private abstract static class AbstractRuleMeasureFilter<M> extends MetricFilter<M> {
192 protected AbstractRuleMeasureFilter(Metric metric) {
193 super(metric);
194 }
195
196 private boolean apply(Measure measure) {
197 return measure instanceof RuleMeasure
198 && filterOnMetricKey().equals(measure.getMetricKey())
199 && measure.getPersonId() == null
200 && doApply((RuleMeasure) measure);
201 }
202
203 abstract boolean doApply(RuleMeasure ruleMeasure);
204
205 public M filter(Collection<Measure> measures) {
206 if (measures == null) {
207 return null;
208 }
209 for (Measure measure : measures) {
210 if (apply(measure)) {
211 return (M) measure;
212 }
213 }
214 return null;
215 }
216 }
217
218 private static class RuleFilter extends AbstractRuleMeasureFilter<RuleMeasure> {
219 private Rule rule;
220
221 protected RuleFilter(Metric metric, Rule rule) {
222 super(metric);
223 this.rule = rule;
224 }
225
226 @Override
227 boolean doApply(RuleMeasure measure) {
228 return measure.getRule() != null
229 && rule.equals(measure.getRule());
230 }
231 }
232 }