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 }