001 /*
002 * Sonar, open source software quality management tool.
003 * Copyright (C) 2009 SonarSource SA
004 * mailto:contact AT sonarsource DOT com
005 *
006 * Sonar 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 * Sonar 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
017 * License along with Sonar; if not, write to the Free Software
018 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02
019 */
020 package org.sonar.api.measures;
021
022 import org.sonar.api.qualitymodel.Characteristic;
023 import org.sonar.api.rules.Rule;
024 import org.sonar.api.rules.RulePriority;
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 new MetricFilter<Measure>(metric) {
048
049 public Measure filter(Collection<Measure> measures) {
050 if (measures == null) {
051 return null;
052 }
053 for (Measure measure : measures) {
054 if (measure.getClass().equals(Measure.class) &&
055 measure.getMetric().equals(metric) &&
056 measure.getCharacteristic()==null) {
057 return measure;
058 }
059 }
060 return null;
061 }
062 };
063 }
064
065 public static MeasuresFilter<Measure> characteristic(final Metric metric, final Characteristic characteristic) {
066 return new MetricFilter<Measure>(metric) {
067
068 public Measure filter(Collection<Measure> measures) {
069 if (measures == null) {
070 return null;
071 }
072 for (Measure measure : measures) {
073 if (measure.getClass().equals(Measure.class) &&
074 measure.getMetric().equals(metric) &&
075 measure.getCharacteristic()!=null &&
076 measure.getCharacteristic().equals(characteristic)) {
077 return measure;
078 }
079 }
080 return null;
081 }
082 };
083 }
084
085 /**
086 * @since 2.0
087 */
088 public static MeasuresFilter<Measure> measure(final Measure measure) {
089 return new MeasuresFilter<Measure>() {
090 public Measure filter(Collection<Measure> measures) {
091 if (measures==null) {
092 return null;
093 }
094 for (Measure m : measures) {
095 if (m.equals(measure)) {
096 return m;
097 }
098 }
099 return null;
100 }
101 };
102 }
103
104 public static MeasuresFilter<RuleMeasure> rulePriority(final Metric metric, final RulePriority priority) {
105 return new RulePriorityFilter(metric, priority);
106 }
107
108 public static MeasuresFilter<RuleMeasure> ruleCategory(final Metric metric, final Integer category) {
109 return new RuleCategoryFilter(metric, category);
110 }
111
112 public static MeasuresFilter<RuleMeasure> rule(final Metric metric, final Rule rule) {
113 return new RuleFilter(metric, rule);
114 }
115
116 public static MeasuresFilter<Collection<RuleMeasure>> ruleCategories(final Metric metric) {
117 return new MetricFilter<Collection<RuleMeasure>>(metric) {
118
119 private boolean apply(Measure measure) {
120 return measure instanceof RuleMeasure
121 && metric.equals(measure.getMetric())
122 && ((RuleMeasure) measure).getRule() == null
123 && ((RuleMeasure) measure).getRuleCategory() != null;
124 }
125
126 public Collection<RuleMeasure> filter(Collection<Measure> measures) {
127 List<RuleMeasure> result = new ArrayList<RuleMeasure>();
128 if (measures != null) {
129 for (Measure measure : measures) {
130 if (apply(measure)) {
131 result.add((RuleMeasure) measure);
132 }
133 }
134 }
135 return result;
136 }
137 };
138 }
139
140 public static MeasuresFilter<Collection<RuleMeasure>> rules(final Metric metric) {
141 return new MetricFilter<Collection<RuleMeasure>>(metric) {
142
143 private boolean apply(Measure measure) {
144 return measure instanceof RuleMeasure
145 && metric.equals(measure.getMetric())
146 && ((RuleMeasure) measure).getRule() != null;
147 }
148
149 public Collection<RuleMeasure> filter(Collection<Measure> measures) {
150 if (measures == null) {
151 return null;
152 }
153 List<RuleMeasure> result = new ArrayList<RuleMeasure>();
154 for (Measure measure : measures) {
155 if (apply(measure)) {
156 result.add((RuleMeasure) measure);
157 }
158 }
159 return result;
160 }
161 };
162 }
163
164 /**
165 * Used for internal optimizations.
166 */
167 public static abstract class MetricFilter<M> implements MeasuresFilter<M> {
168 private final Metric metric;
169
170 protected MetricFilter(Metric metric) {
171 this.metric = metric;
172 }
173
174 public Metric filterOnMetric() {
175 return metric;
176 }
177 }
178
179 private abstract static class AbstractRuleMeasureFilter<M> extends MetricFilter<M> {
180 protected AbstractRuleMeasureFilter(Metric metric) {
181 super(metric);
182 }
183
184 private boolean apply(Measure measure) {
185 return measure instanceof RuleMeasure
186 && filterOnMetric().equals(measure.getMetric())
187 && doApply((RuleMeasure) measure);
188 }
189
190 abstract boolean doApply(RuleMeasure ruleMeasure);
191
192 public M filter(Collection<Measure> measures) {
193 if (measures == null) {
194 return null;
195 }
196 for (Measure measure : measures) {
197 if (apply(measure)) {
198 return (M) measure;
199 }
200 }
201 return null;
202 }
203 }
204
205 private static class RulePriorityFilter extends AbstractRuleMeasureFilter<RuleMeasure> {
206 private RulePriority priority;
207
208 protected RulePriorityFilter(Metric metric, RulePriority priority) {
209 super(metric);
210 this.priority = priority;
211 }
212
213 @Override
214 boolean doApply(RuleMeasure measure) {
215 return measure.getRule() == null
216 && measure.getRuleCategory() == null
217 && priority.equals(measure.getRulePriority());
218 }
219 }
220
221 private static class RuleCategoryFilter extends AbstractRuleMeasureFilter<RuleMeasure> {
222 private Integer categ;
223
224 protected RuleCategoryFilter(Metric metric, Integer categ) {
225 super(metric);
226 this.categ = categ;
227 }
228
229 @Override
230 boolean doApply(RuleMeasure measure) {
231 return measure.getRule() == null
232 && categ.equals(measure.getRuleCategory())
233 && measure.getRulePriority() == null;
234 }
235 }
236
237
238 private static class RuleFilter extends AbstractRuleMeasureFilter<RuleMeasure> {
239 private Rule rule;
240
241 protected RuleFilter(Metric metric, Rule rule) {
242 super(metric);
243 this.rule = rule;
244 }
245
246 @Override
247 boolean doApply(RuleMeasure measure) {
248 return measure.getRule() != null
249 && rule.equals(measure.getRule());
250 }
251 }
252 }