Clover Coverage Report
Coverage timestamp: Fri Feb 14 2014 01:47:57 UTC
../../../../../../img/srcFileCovDistChart9.png 31% of files have more coverage
178   422   70   8.9
78   315   0.39   20
20     3.5  
1    
 
  ModuleConstantsExistenceCheckerImpl       Line # 44 178 70 87.3% 0.8731884
 
  (104)
 
1    /* This file is part of the project "Hilbert II" - http://www.qedeq.org
2    *
3    * Copyright 2000-2014, Michael Meyling <mime@qedeq.org>.
4    *
5    * "Hilbert II" is free software; you can redistribute
6    * it and/or modify it under the terms of the GNU General Public
7    * License as published by the Free Software Foundation; either
8    * version 2 of the License, or (at your option) any later version.
9    *
10    * This program is distributed in the hope that it will be useful,
11    * but WITHOUT ANY WARRANTY; without even the implied warranty of
12    * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13    * GNU General Public License for more details.
14    */
15   
16    package org.qedeq.kernel.bo.service.logic;
17   
18    import java.util.HashMap;
19    import java.util.Iterator;
20    import java.util.Map;
21    import java.util.Set;
22   
23    import org.qedeq.kernel.bo.common.ModuleReferenceList;
24    import org.qedeq.kernel.bo.logic.common.ClassOperatorAlreadyExistsException;
25    import org.qedeq.kernel.bo.logic.common.FunctionConstant;
26    import org.qedeq.kernel.bo.logic.common.FunctionKey;
27    import org.qedeq.kernel.bo.logic.common.IdentityOperatorAlreadyExistsException;
28    import org.qedeq.kernel.bo.logic.common.PredicateConstant;
29    import org.qedeq.kernel.bo.logic.common.PredicateKey;
30    import org.qedeq.kernel.bo.module.KernelQedeqBo;
31    import org.qedeq.kernel.bo.module.ModuleConstantsExistenceChecker;
32    import org.qedeq.kernel.se.base.module.Rule;
33    import org.qedeq.kernel.se.common.IllegalModuleDataException;
34    import org.qedeq.kernel.se.common.ModuleContext;
35    import org.qedeq.kernel.se.common.ModuleDataException;
36    import org.qedeq.kernel.se.common.RuleKey;
37   
38   
39    /**
40    * Checks if a predicate or function constant is defined.
41    *
42    * @author Michael Meyling
43    */
 
44    public class ModuleConstantsExistenceCheckerImpl extends DefaultExistenceChecker
45    implements ModuleConstantsExistenceChecker {
46   
47    /** QEDEQ module properties. */
48    private final KernelQedeqBo prop;
49   
50    /** In this module the class operator is defined. */
51    private KernelQedeqBo classOperatorModule;
52   
53    /** In this class the identityOperator is defined. */
54    private KernelQedeqBo identityOperatorModule;
55   
56    /**
57    * Constructor.
58    *
59    * @param prop QEDEQ module properties object.
60    * @throws ModuleDataException Referenced QEDEQ modules are already inconsistent: they doesn't
61    * mix.
62    */
 
63  337 toggle public ModuleConstantsExistenceCheckerImpl(final KernelQedeqBo prop) throws ModuleDataException {
64  337 super();
65  337 this.prop = prop;
66  337 init();
67    }
68   
69    /**
70    * Check if required QEDEQ modules mix without problems. If for example the identity operator
71    * is defined in two different modules in two different ways we have got a problem.
72    * Also the basic properties (for example
73    * {@link ModuleConstantsExistenceCheckerImpl#setIdentityOperatorDefined(String,
74    * KernelQedeqBo, ModuleContext)} and
75    * {@link ModuleConstantsExistenceCheckerImpl#setClassOperatorModule(KernelQedeqBo)}) are set accordingly.
76    *
77    * @throws ModuleDataException Required modules doesn't mix.
78    */
 
79  337 toggle public final void init() throws ModuleDataException {
80  337 clear();
81  337 final ModuleReferenceList list = prop.getRequiredModules();
82  337 final Map rules = new HashMap();
83  497 for (int i = 0; i < list.size(); i++) {
84  162 final KernelQedeqBo bo = (KernelQedeqBo) list
85    .getQedeqBo(i);
86  162 if (bo.getExistenceChecker().identityOperatorExists()) {
87  134 final String identityOperator = list.getLabel(i) + "."
88    + bo.getExistenceChecker().getIdentityOperator();
89  134 setIdentityOperatorDefined(identityOperator,
90    bo.getExistenceChecker().getIdentityOperatorModule(),
91    list.getModuleContext(i));
92    }
93  160 if (bo.getExistenceChecker().classOperatorExists()) {
94  15 setClassOperatorModule(bo.getExistenceChecker().getClassOperatorModule(),
95    list.getModuleContext(i));
96    }
97  160 final Map cut = bo.getExistenceChecker().getRules();
98  160 final Iterator iter = cut.entrySet().iterator();
99  1690 while (iter.hasNext()) {
100  1530 final Map.Entry entry = (Map.Entry) iter.next();
101  1530 final RuleKey key = (RuleKey) entry.getKey();
102  1530 if (rules.containsKey(key) && !rules.get(key).equals(entry.getValue())) {
103  0 throw new IllegalModuleDataException(
104    LogicErrors.RULE_DEFINITIONS_DONT_MIX_CODE,
105    LogicErrors.RULE_DEFINITIONS_DONT_MIX_TEXT + key + " in "
106    + ((KernelQedeqBo) rules.get(key)).getLabels().getRuleContext(key),
107    list.getModuleContext(i),
108    getQedeq(key).getLabels().getRuleContext(key));
109    }
110    }
111  160 rules.putAll(bo.getExistenceChecker().getRules());
112    }
113    }
114   
 
115  55025 toggle public boolean predicateExists(final PredicateKey predicate) {
116  55025 final String name = predicate.getName();
117  55025 final String arguments = predicate.getArguments();
118  55025 final int external = name.indexOf('.');
119  55025 if (external < 0) {
120  39925 return super.predicateExists(predicate);
121    }
122  15100 final String label = name.substring(0, external);
123  15100 final ModuleReferenceList ref = prop.getRequiredModules();
124   
125  15100 final KernelQedeqBo newProp = (KernelQedeqBo) ref
126    .getQedeqBo(label);
127  15100 if (newProp == null) {
128  2 return false;
129    }
130  15098 final String shortName = name.substring(external + 1);
131  15098 return newProp.getExistenceChecker().predicateExists(new PredicateKey(shortName, arguments));
132    }
133   
 
134  19843 toggle public boolean functionExists(final FunctionKey function) {
135  19843 final String name = function.getName();
136  19843 final String arguments = function.getArguments();
137  19843 final int external = name.indexOf(".");
138  19843 if (external < 0) {
139  19837 return super.functionExists(function);
140    }
141  6 final String label = name.substring(0, external);
142  6 final ModuleReferenceList ref = prop.getRequiredModules();
143  6 final KernelQedeqBo newProp = (KernelQedeqBo) ref.getQedeqBo(label);
144  6 if (newProp == null) {
145  3 return false;
146    }
147  3 final String shortName = name.substring(external + 1);
148  3 return newProp.getExistenceChecker().functionExists(new FunctionKey(shortName, arguments));
149    }
150   
 
151  5 toggle public boolean isInitialPredicate(final PredicateKey predicate) {
152  5 final String name = predicate.getName();
153  5 final String arguments = predicate.getArguments();
154  5 final int external = name.indexOf('.');
155  5 if (external < 0) {
156  2 return super.isInitialPredicate(predicate);
157    }
158  3 final String label = name.substring(0, external);
159  3 final ModuleReferenceList ref = prop.getRequiredModules();
160   
161  3 final KernelQedeqBo newProp = (KernelQedeqBo) ref
162    .getQedeqBo(label);
163  3 if (newProp == null) {
164  1 return false;
165    }
166  2 final String shortName = name.substring(external + 1);
167  2 return newProp.getExistenceChecker().isInitialPredicate(
168    new PredicateKey(shortName, arguments));
169    }
170   
 
171  4 toggle public boolean isInitialFunction(final FunctionKey function) {
172  4 final String name = function.getName();
173  4 final String arguments = function.getArguments();
174  4 final int external = name.indexOf('.');
175  4 if (external < 0) {
176  2 return super.isInitialFunction(function);
177    }
178  2 final String label = name.substring(0, external);
179  2 final ModuleReferenceList ref = prop.getRequiredModules();
180   
181  2 final KernelQedeqBo newProp = (KernelQedeqBo) ref
182    .getQedeqBo(label);
183  2 if (newProp == null) {
184  0 return false;
185    }
186  2 final String shortName = name.substring(external + 1);
187  2 return newProp.getExistenceChecker().isInitialFunction(
188    new FunctionKey(shortName, arguments));
189    }
190   
 
191  66996 toggle public PredicateConstant get(final PredicateKey predicate) {
192  66996 final String name = predicate.getName();
193  66996 final String arguments = predicate.getArguments();
194  66996 final int external = name.indexOf('.');
195  66996 if (external < 0) {
196  66991 return super.get(predicate);
197    }
198  5 final String label = name.substring(0, external);
199  5 final ModuleReferenceList ref = prop.getRequiredModules();
200   
201  5 final KernelQedeqBo newProp = (KernelQedeqBo) ref
202    .getQedeqBo(label);
203  5 if (newProp == null) {
204  2 return null;
205    }
206  3 final String shortName = name.substring(external + 1);
207  3 return newProp.getExistenceChecker().get(new PredicateKey(shortName, arguments));
208    }
209   
 
210  6514 toggle public FunctionConstant get(final FunctionKey function) {
211  6514 final String name = function.getName();
212  6514 final String arguments = function.getArguments();
213  6514 final int external = name.indexOf(".");
214  6514 if (external < 0) {
215  6508 return super.get(function);
216    }
217  6 final String label = name.substring(0, external);
218  6 final ModuleReferenceList ref = prop.getRequiredModules();
219  6 final KernelQedeqBo newProp = (KernelQedeqBo) ref
220    .getQedeqBo(label);
221  6 if (newProp == null) {
222  2 return null;
223    }
224  4 final String shortName = name.substring(external + 1);
225  4 return newProp.getExistenceChecker().get(new FunctionKey(shortName, arguments));
226    }
227   
228    /**
229    * Get QEDEQ module where given function constant is defined.
230    *
231    * @param function Function we look for.
232    * @return QEDEQ module where function constant is defined.
233    */
 
234  10 toggle public KernelQedeqBo getQedeq(final FunctionKey function) {
235  10 final String name = function.getName();
236  10 final String arguments = function.getArguments();
237  10 final int external = name.indexOf(".");
238  10 if (external < 0) {
239  6 if (functionExists(function)) {
240  2 return prop;
241    }
242  4 return null;
243    }
244  4 final String label = name.substring(0, external);
245  4 final ModuleReferenceList ref = prop.getRequiredModules();
246  4 final KernelQedeqBo newProp = (KernelQedeqBo) ref.getQedeqBo(label);
247  4 if (newProp == null) {
248  2 return newProp;
249    }
250  2 final String shortName = name.substring(external + 1);
251  2 return newProp.getExistenceChecker().getQedeq(new FunctionKey(shortName, arguments));
252    }
253   
254    /**
255    * Get QEDEQ module where given predicate constant is defined.
256    *
257    * @param predicate Predicate we look for.
258    * @return QEDEQ module where predicate constant is defined.x
259    */
 
260  10 toggle public KernelQedeqBo getQedeq(final PredicateKey predicate) {
261  10 final String name = predicate.getName();
262  10 final String arguments = predicate.getArguments();
263  10 final int external = name.indexOf(".");
264  10 if (external < 0) {
265  6 if (predicateExists(predicate)) {
266  2 return prop;
267    }
268  4 return null;
269    }
270  4 final String label = name.substring(0, external);
271  4 final ModuleReferenceList ref = prop.getRequiredModules();
272  4 final KernelQedeqBo newProp = (KernelQedeqBo) ref.getQedeqBo(label);
273  4 if (newProp == null) {
274  2 return newProp;
275    }
276  2 final String shortName = name.substring(external + 1);
277  2 return newProp.getExistenceChecker().getQedeq(new PredicateKey(shortName, arguments));
278    }
279   
 
280  0 toggle public RuleKey getRuleKey(final String ruleName) {
281  0 RuleKey ruleKey = prop.getLabels().getRuleKey(ruleName);
282  0 final ModuleReferenceList ref = prop.getRequiredModules();
283  0 for (int i = 0; i < ref.size(); i++) {
284  0 final KernelQedeqBo newProp = (KernelQedeqBo) ref.getQedeqBo(i);
285  0 final RuleKey found = newProp.getExistenceChecker().getRuleKey(ruleName);
286  0 if (found != null && found.getVersion() != null && (ruleKey == null
287    || ruleKey.getVersion() == null
288    || 0 < found.getVersion().compareTo(ruleKey.getVersion()))) {
289  0 ruleKey = found;
290    }
291    }
292  0 return ruleKey;
293    }
294   
 
295  0 toggle public RuleKey getParentRuleKey(final String ruleName) {
296  0 RuleKey ruleKey = null;
297  0 final ModuleReferenceList ref = prop.getRequiredModules();
298  0 for (int i = 0; i < ref.size(); i++) {
299  0 final KernelQedeqBo newProp = (KernelQedeqBo) ref.getQedeqBo(i);
300  0 final RuleKey found = newProp.getExistenceChecker().getRuleKey(ruleName);
301  0 if (found != null && found.getVersion() != null && (ruleKey == null
302    || ruleKey.getVersion() == null
303    || 0 < found.getVersion().compareTo(ruleKey.getVersion()))) {
304  0 ruleKey = found;
305    }
306    }
307  0 return ruleKey;
308    }
309   
 
310  1922 toggle public Rule get(final RuleKey ruleKey) {
311  1922 final Rule local = super.get(ruleKey);
312  1922 if (null != local) {
313  2 return local;
314    }
315  1920 final ModuleReferenceList ref = prop.getRequiredModules();
316  1989 for (int i = 0; i < ref.size(); i++) {
317  71 final KernelQedeqBo newProp = (KernelQedeqBo) ref.getQedeqBo(i);
318  71 final Rule found = (newProp.getExistenceChecker().get(ruleKey));
319  71 if (found != null) {
320  2 return found;
321    }
322    }
323  1918 return null;
324    }
325   
 
326  580 toggle public Map getRules() {
327  580 final Map result = new HashMap();
328  580 final Set keys = prop.getLabels().getRuleDefinitions().keySet();
329  580 final Iterator iter = keys.iterator();
330  5174 while (iter.hasNext()) {
331  4594 result.put(iter.next(), prop);
332    }
333  580 final ModuleReferenceList ref = prop.getRequiredModules();
334  661 for (int i = 0; i < ref.size(); i++) {
335  81 final KernelQedeqBo newProp = (KernelQedeqBo) ref.getQedeqBo(i);
336  81 result.putAll(newProp.getExistenceChecker().getRules());
337    }
338  580 return result;
339    }
340   
341    /**
342    * Get QEDEQ module where given rule is defined.
343    *
344    * @param ruleKey Rule we look for.
345    * @return QEDEQ module where rule is defined. Could be <code>null</code>.
346    */
 
347  3947 toggle public KernelQedeqBo getQedeq(final RuleKey ruleKey) {
348  3947 if (super.get(ruleKey) != null) {
349  3794 return prop;
350    }
351  153 final ModuleReferenceList ref = prop.getRequiredModules();
352  153 for (int i = 0; i < ref.size(); i++) {
353  153 final KernelQedeqBo newProp = (KernelQedeqBo) ref.getQedeqBo(i);
354  153 final KernelQedeqBo found = (newProp.getExistenceChecker().getQedeq(ruleKey));
355  153 if (found != null) {
356  153 return found;
357    }
358    }
359  0 return null;
360    }
361   
 
362  3342 toggle public boolean classOperatorExists() {
363  3342 return classOperatorModule != null;
364    }
365   
366    /**
367    * Set the identity operator.
368    *
369    * @param identityOperator Operator name. Might be <code>null</code>.
370    * @param identityOperatorModule In this module the identity operator is defined.
371    * @param context Here we are within the module.
372    * @throws IdentityOperatorAlreadyExistsException Already defined.
373    */
 
374  248 toggle public void setIdentityOperatorDefined(final String identityOperator,
375    final KernelQedeqBo identityOperatorModule, final ModuleContext context)
376    throws IdentityOperatorAlreadyExistsException {
377  248 if (this.identityOperatorModule != null && identityOperatorModule != null) {
378  21 if (!this.identityOperatorModule.equals(identityOperatorModule)) {
379  8 throw new IdentityOperatorAlreadyExistsException(
380    LogicErrors.IDENTITY_OPERATOR_ALREADY_EXISTS_CODE,
381    LogicErrors.IDENTITY_OPERATOR_ALREADY_EXISTS_TEXT + " " + getIdentityOperator(),
382    context);
383    }
384    } else {
385  227 this.identityOperatorModule = identityOperatorModule;
386  227 super.setIdentityOperatorDefined(identityOperator);
387    }
388    }
389   
 
390  6551 toggle public KernelQedeqBo getClassOperatorModule() {
391  6551 return classOperatorModule;
392    }
393   
 
394  134 toggle public KernelQedeqBo getIdentityOperatorModule() {
395  134 return identityOperatorModule;
396    }
397   
398    /**
399    * Set if the class operator is already defined.
400    *
401    * @param classOperatorModule Module where class operator is defined.
402    * @param context Context where we try to set new class operator.
403    * @throws ClassOperatorAlreadyExistsException Operator already defined.
404    */
 
405  94 toggle public void setClassOperatorModule(final KernelQedeqBo classOperatorModule,
406    final ModuleContext context) throws ClassOperatorAlreadyExistsException {
407  94 if (this.classOperatorModule != null && classOperatorModule != null) {
408    // FIXME 20130109 m31: why do we have this if question? If we define
409    // the class operator twice in the same module we also want to get an error!
410  1 if (!this.classOperatorModule.equals(classOperatorModule)) {
411  0 throw new ClassOperatorAlreadyExistsException(
412    LogicErrors.CLASS_OPERATOR_ALREADY_DEFINED_CODE,
413    LogicErrors.CLASS_OPERATOR_ALREADY_DEFINED_TEXT
414    + this.classOperatorModule.getUrl(),
415    context);
416    }
417    } else {
418  93 this.classOperatorModule = classOperatorModule;
419    }
420    }
421   
422    }