001 /* 002 * Sonar, open source software quality management tool. 003 * Copyright (C) 2008-2011 SonarSource 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 025 import java.util.ArrayList; 026 import java.util.Collection; 027 import java.util.Collections; 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 return measure; 062 } 063 } 064 return null; 065 } 066 }; 067 } 068 069 public static MeasuresFilter<Measure> characteristic(final Metric metric, final Characteristic characteristic) { 070 return new MetricFilter<Measure>(metric) { 071 072 public Measure filter(Collection<Measure> measures) { 073 if (measures == null) { 074 return null; 075 } 076 for (Measure measure : measures) { 077 if (measure.getClass().equals(Measure.class) && 078 measure.getMetric().equals(metric) && 079 measure.getCharacteristic() != null && 080 measure.getCharacteristic().equals(characteristic)) { 081 return measure; 082 } 083 } 084 return null; 085 } 086 }; 087 } 088 089 /** 090 * @since 2.0 091 */ 092 public static MeasuresFilter<Measure> measure(final Measure measure) { 093 return new MeasuresFilter<Measure>() { 094 public Measure filter(Collection<Measure> measures) { 095 if (measures == null) { 096 return null; 097 } 098 for (Measure m : measures) { 099 if (m.equals(measure)) { 100 return m; 101 } 102 } 103 return null; 104 } 105 }; 106 } 107 108 /** 109 * @deprecated since 2.5. See http://jira.codehaus.org/browse/SONAR-2007 110 */ 111 @Deprecated 112 public static MeasuresFilter<RuleMeasure> ruleCategory(final Metric metric, final Integer category) { 113 return new RuleCategoryFilter(metric, category); 114 } 115 116 public static MeasuresFilter<RuleMeasure> rule(final Metric metric, final Rule rule) { 117 return new RuleFilter(metric, rule); 118 } 119 120 /** 121 * @deprecated since 2.5. See http://jira.codehaus.org/browse/SONAR-2007 122 */ 123 @Deprecated 124 public static MeasuresFilter<Collection<RuleMeasure>> ruleCategories(final Metric metric) { 125 return new MetricFilter<Collection<RuleMeasure>>(metric) { 126 127 public Collection<RuleMeasure> filter(Collection<Measure> measures) { 128 return Collections.emptyList(); 129 } 130 }; 131 } 132 133 public static MeasuresFilter<Collection<RuleMeasure>> rules(final Metric metric) { 134 return new MetricFilter<Collection<RuleMeasure>>(metric) { 135 136 private boolean apply(Measure measure) { 137 return measure instanceof RuleMeasure 138 && metric.equals(measure.getMetric()) 139 && ((RuleMeasure) measure).getRule() != null; 140 } 141 142 public Collection<RuleMeasure> filter(Collection<Measure> measures) { 143 if (measures == null) { 144 return null; 145 } 146 List<RuleMeasure> result = new ArrayList<RuleMeasure>(); 147 for (Measure measure : measures) { 148 if (apply(measure)) { 149 result.add((RuleMeasure) measure); 150 } 151 } 152 return result; 153 } 154 }; 155 } 156 157 /** 158 * Used for internal optimizations. 159 */ 160 public static abstract class MetricFilter<M> implements MeasuresFilter<M> { 161 private final String metricKey; 162 163 protected MetricFilter(Metric metric) { 164 this.metricKey = metric.getKey(); 165 } 166 167 protected MetricFilter(String metricKey) { 168 this.metricKey = metricKey; 169 } 170 171 public String filterOnMetricKey() { 172 return metricKey; 173 } 174 } 175 176 private abstract static class AbstractRuleMeasureFilter<M> extends MetricFilter<M> { 177 protected AbstractRuleMeasureFilter(Metric metric) { 178 super(metric); 179 } 180 181 private boolean apply(Measure measure) { 182 return measure instanceof RuleMeasure 183 && filterOnMetricKey().equals(measure.getMetricKey()) 184 && doApply((RuleMeasure) measure); 185 } 186 187 abstract boolean doApply(RuleMeasure ruleMeasure); 188 189 public M filter(Collection<Measure> measures) { 190 if (measures == null) { 191 return null; 192 } 193 for (Measure measure : measures) { 194 if (apply(measure)) { 195 return (M) measure; 196 } 197 } 198 return null; 199 } 200 } 201 202 /** 203 * @deprecated since 2.5. See http://jira.codehaus.org/browse/SONAR-2007 204 */ 205 @Deprecated 206 private static class RuleCategoryFilter extends AbstractRuleMeasureFilter<RuleMeasure> { 207 208 protected RuleCategoryFilter(Metric metric, Integer categ) { 209 super(metric); 210 } 211 212 @Override 213 boolean doApply(RuleMeasure measure) { 214 return false; 215 } 216 } 217 218 219 private static class RuleFilter extends AbstractRuleMeasureFilter<RuleMeasure> { 220 private Rule rule; 221 222 protected RuleFilter(Metric metric, Rule rule) { 223 super(metric); 224 this.rule = rule; 225 } 226 227 @Override 228 boolean doApply(RuleMeasure measure) { 229 return measure.getRule() != null 230 && rule.equals(measure.getRule()); 231 } 232 } 233 }