AbstractDelegateRule.java
001 /**
002  * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
003  */
004 package net.sourceforge.pmd.lang.rule;
005 
006 import java.util.List;
007 import java.util.Map;
008 
009 import net.sourceforge.pmd.PropertyDescriptor;
010 import net.sourceforge.pmd.Rule;
011 import net.sourceforge.pmd.RuleContext;
012 import net.sourceforge.pmd.RulePriority;
013 import net.sourceforge.pmd.lang.Language;
014 import net.sourceforge.pmd.lang.LanguageVersion;
015 import net.sourceforge.pmd.lang.ast.Node;
016 
017 /**
018  * Base class for Rule implementations which delegate to another Rule instance.
019  */
020 public abstract class AbstractDelegateRule implements Rule {
021 
022   private Rule rule;
023 
024   public void setRule(Rule rule) {
025     this.rule = rule;
026   }
027 
028   public Rule getRule() {
029     return rule;
030   }
031 
032   public Language getLanguage() {
033     return rule.getLanguage();
034   }
035 
036   public void setLanguage(Language language) {
037     rule.setLanguage(language);
038   }
039 
040   public LanguageVersion getMinimumLanguageVersion() {
041     return rule.getMinimumLanguageVersion();
042   }
043 
044   public void setMinimumLanguageVersion(LanguageVersion minimumlanguageVersion) {
045     rule.setMinimumLanguageVersion(minimumlanguageVersion);
046   }
047 
048   public void setMaximumLanguageVersion(LanguageVersion maximumlanguageVersion) {
049     rule.setMaximumLanguageVersion(maximumlanguageVersion);
050   }
051 
052   public LanguageVersion getMaximumLanguageVersion() {
053     return rule.getMaximumLanguageVersion();
054   }
055 
056   public boolean isDeprecated() {
057     return rule.isDeprecated();
058   }
059 
060   public void setDeprecated(boolean deprecated) {
061     rule.setDeprecated(deprecated);
062   }
063 
064   public String getName() {
065     return rule.getName();
066   }
067 
068   public void setName(String name) {
069     rule.setName(name);
070   }
071 
072   public String getSince() {
073     return rule.getSince();
074   }
075 
076   public void setSince(String since) {
077     rule.setSince(since);
078   }
079 
080   public String getRuleClass() {
081     return rule.getRuleClass();
082   }
083 
084   public void setRuleClass(String ruleClass) {
085     rule.setRuleClass(ruleClass);
086   }
087 
088   public String getRuleSetName() {
089     return rule.getRuleSetName();
090   }
091 
092   public void setRuleSetName(String name) {
093     rule.setRuleSetName(name);
094   }
095 
096   public String getMessage() {
097     return rule.getMessage();
098   }
099 
100   public void setMessage(String message) {
101     rule.setMessage(message);
102   }
103 
104   public String getDescription() {
105     return rule.getDescription();
106   }
107 
108   public void setDescription(String description) {
109     rule.setDescription(description);
110   }
111 
112   public List<String> getExamples() {
113     return rule.getExamples();
114   }
115 
116   public void addExample(String example) {
117     rule.addExample(example);
118   }
119 
120   public String getExternalInfoUrl() {
121     return rule.getExternalInfoUrl();
122   }
123 
124   public void setExternalInfoUrl(String url) {
125     rule.setExternalInfoUrl(url);
126   }
127 
128   public RulePriority getPriority() {
129     return rule.getPriority();
130   }
131 
132   public void setPriority(RulePriority priority) {
133     rule.setPriority(priority);
134   }
135 
136   public void definePropertyDescriptor(PropertyDescriptor<?> propertyDescriptorthrows IllegalArgumentException {
137       rule.definePropertyDescriptor(propertyDescriptor);
138   }
139 
140   public PropertyDescriptor<?> getPropertyDescriptor(String name) {
141       return rule.getPropertyDescriptor(name);
142   }
143 
144   public List<PropertyDescriptor<?>> getPropertyDescriptors() {
145       return rule.getPropertyDescriptors();
146   }
147 
148   public <T> T getProperty(PropertyDescriptor<T> propertyDescriptor) {
149       return rule.getProperty(propertyDescriptor);
150   }
151 
152   public <T> void setProperty(PropertyDescriptor<T> propertyDescriptor, T value) {
153       rule.setProperty(propertyDescriptor, value);
154   }
155 
156   public Map<PropertyDescriptor<?>, Object> getPropertiesByPropertyDescriptor() {
157       return rule.getPropertiesByPropertyDescriptor();
158   }
159 
160   public void setUsesDFA() {
161      rule.setUsesDFA();
162    }
163 
164    public boolean usesDFA() {
165      return rule.usesDFA();
166    }
167 
168    public void setUsesTypeResolution() {
169      rule.setUsesTypeResolution();
170    }
171 
172    public boolean usesTypeResolution() {
173      return rule.usesTypeResolution();
174    }
175 
176    public boolean usesRuleChain() {
177      return rule.usesRuleChain();
178    }
179 
180    public List<String> getRuleChainVisits() {
181      return rule.getRuleChainVisits();
182    }
183 
184    public void addRuleChainVisit(Class<? extends Node> nodeClass) {
185      rule.addRuleChainVisit(nodeClass);
186    }
187 
188    public void addRuleChainVisit(String astNodeName) {
189      rule.addRuleChainVisit(astNodeName);
190    }
191 
192    public void start(RuleContext ctx) {
193      rule.start(ctx);
194    }
195 
196    public void apply(List<? extends Node> nodes, RuleContext ctx) {
197      rule.apply(nodes, ctx);
198    }
199 
200    public void end(RuleContext ctx) {
201      rule.end(ctx);
202    }
203    
204     /**
205      @see Rule#hasDescriptor(PropertyDescriptor)
206      */
207     public boolean hasDescriptor(PropertyDescriptor<?> descriptor) {            
208       return rule.hasDescriptor(descriptor);
209     }
210 }