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.rules.Rule; 023 import org.sonar.api.rules.RulePriority; 024 025 import java.util.ArrayList; 026 import java.util.Collection; 027 import java.util.List; 028 029 /** 030 * @since 1.10 031 */ 032 public final class MeasuresFilters { 033 034 private MeasuresFilters() { 035 } 036 037 public static MeasuresFilter<Collection<Measure>> all() { 038 return new MeasuresFilter<Collection<Measure>>() { 039 public Collection<Measure> filter(Collection<Measure> measures) { 040 return measures; 041 } 042 }; 043 } 044 045 public static MeasuresFilter<Measure> metric(final Metric metric) { 046 return new MetricFilter<Measure>(metric) { 047 048 public Measure filter(Collection<Measure> measures) { 049 if (measures == null) { 050 return null; 051 } 052 for (Measure measure : measures) { 053 if (measure.getClass().equals(Measure.class) && 054 measure.getMetric().equals(metric)) { 055 return measure; 056 } 057 } 058 return null; 059 } 060 }; 061 } 062 063 public static MeasuresFilter<RuleMeasure> rulePriority(final Metric metric, final RulePriority priority) { 064 return new RulePriorityFilter(metric, priority); 065 } 066 067 public static MeasuresFilter<RuleMeasure> ruleCategory(final Metric metric, final Integer category) { 068 return new RuleCategoryFilter(metric, category); 069 } 070 071 public static MeasuresFilter<RuleMeasure> rule(final Metric metric, final Rule rule) { 072 return new RuleFilter(metric, rule); 073 } 074 075 public static MeasuresFilter<Collection<RuleMeasure>> ruleCategories(final Metric metric) { 076 return new MetricFilter<Collection<RuleMeasure>>(metric) { 077 078 private boolean apply(Measure measure) { 079 return measure instanceof RuleMeasure 080 && metric.equals(measure.getMetric()) 081 && ((RuleMeasure) measure).getRule() == null 082 && ((RuleMeasure) measure).getRuleCategory() != null; 083 } 084 085 public Collection<RuleMeasure> filter(Collection<Measure> measures) { 086 List<RuleMeasure> result = new ArrayList<RuleMeasure>(); 087 if (measures != null) { 088 for (Measure measure : measures) { 089 if (apply(measure)) { 090 result.add((RuleMeasure) measure); 091 } 092 } 093 } 094 return result; 095 } 096 }; 097 } 098 099 public static MeasuresFilter<Collection<RuleMeasure>> rules(final Metric metric) { 100 return new MetricFilter<Collection<RuleMeasure>>(metric) { 101 102 private boolean apply(Measure measure) { 103 return measure instanceof RuleMeasure 104 && metric.equals(measure.getMetric()) 105 && ((RuleMeasure) measure).getRule() != null; 106 } 107 108 public Collection<RuleMeasure> filter(Collection<Measure> measures) { 109 if (measures == null) { 110 return null; 111 } 112 List<RuleMeasure> result = new ArrayList<RuleMeasure>(); 113 for (Measure measure : measures) { 114 if (apply(measure)) { 115 result.add((RuleMeasure) measure); 116 } 117 } 118 return result; 119 } 120 }; 121 } 122 123 /** 124 * Used for internal optimizations. 125 */ 126 public static abstract class MetricFilter<M> implements MeasuresFilter<M> { 127 private final Metric metric; 128 129 protected MetricFilter(Metric metric) { 130 this.metric = metric; 131 } 132 133 public Metric filterOnMetric() { 134 return metric; 135 } 136 } 137 138 private abstract static class AbstractRuleMeasureFilter<M> extends MetricFilter<M> { 139 protected AbstractRuleMeasureFilter(Metric metric) { 140 super(metric); 141 } 142 143 private boolean apply(Measure measure) { 144 return measure instanceof RuleMeasure 145 && filterOnMetric().equals(measure.getMetric()) 146 && doApply((RuleMeasure) measure); 147 } 148 149 abstract boolean doApply(RuleMeasure ruleMeasure); 150 151 public M filter(Collection<Measure> measures) { 152 if (measures == null) { 153 return null; 154 } 155 for (Measure measure : measures) { 156 if (apply(measure)) { 157 return (M) measure; 158 } 159 } 160 return null; 161 } 162 } 163 164 private static class RulePriorityFilter extends AbstractRuleMeasureFilter<RuleMeasure> { 165 private RulePriority priority; 166 167 protected RulePriorityFilter(Metric metric, RulePriority priority) { 168 super(metric); 169 this.priority = priority; 170 } 171 172 @Override 173 boolean doApply(RuleMeasure measure) { 174 return measure.getRule() == null 175 && measure.getRuleCategory() == null 176 && priority.equals(measure.getRulePriority()); 177 } 178 } 179 180 private static class RuleCategoryFilter extends AbstractRuleMeasureFilter<RuleMeasure> { 181 private Integer categ; 182 183 protected RuleCategoryFilter(Metric metric, Integer categ) { 184 super(metric); 185 this.categ = categ; 186 } 187 188 @Override 189 boolean doApply(RuleMeasure measure) { 190 return measure.getRule() == null 191 && categ.equals(measure.getRuleCategory()) 192 && measure.getRulePriority() == null; 193 } 194 } 195 196 197 private static class RuleFilter extends AbstractRuleMeasureFilter<RuleMeasure> { 198 private Rule rule; 199 200 protected RuleFilter(Metric metric, Rule rule) { 201 super(metric); 202 this.rule = rule; 203 } 204 205 @Override 206 boolean doApply(RuleMeasure measure) { 207 return measure.getRule() != null 208 && rule.equals(measure.getRule()); 209 } 210 } 211 }