Clover Coverage Report
Coverage timestamp: Sat Sep 18 2010 04:09:52 UTC
Overview   Package   File
    FRAMES   NO FRAMES     
../../../../../img/srcFileCovDistChart8.png 50% of files have more coverage
69   468   59   1.38
12   225   0.86   50
50     1.18  
1    
 
  DefaultKernelQedeqBo       Line # 46 69 59 79.4% 0.79389316
 
  (58)
 
1    /* This file is part of the project "Hilbert II" - http://www.qedeq.org
2    *
3    * Copyright 2000-2010, 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;
17   
18    import org.qedeq.base.io.SourceArea;
19    import org.qedeq.base.utility.EqualsUtility;
20    import org.qedeq.kernel.base.module.Qedeq;
21    import org.qedeq.kernel.bo.ModuleReferenceList;
22    import org.qedeq.kernel.bo.module.InternalKernelServices;
23    import org.qedeq.kernel.bo.module.KernelModuleReferenceList;
24    import org.qedeq.kernel.bo.module.KernelQedeqBo;
25    import org.qedeq.kernel.bo.module.ModuleLabels;
26    import org.qedeq.kernel.bo.module.PluginBo;
27    import org.qedeq.kernel.bo.module.QedeqFileDao;
28    import org.qedeq.kernel.common.DefaultSourceFileExceptionList;
29    import org.qedeq.kernel.common.DependencyState;
30    import org.qedeq.kernel.common.LoadingState;
31    import org.qedeq.kernel.common.LogicalState;
32    import org.qedeq.kernel.common.ModuleAddress;
33    import org.qedeq.kernel.common.ModuleContext;
34    import org.qedeq.kernel.common.ModuleDataException;
35    import org.qedeq.kernel.common.Plugin;
36    import org.qedeq.kernel.common.SourceFileException;
37    import org.qedeq.kernel.common.SourceFileExceptionList;
38    import org.qedeq.kernel.dto.module.QedeqVo;
39   
40   
41    /**
42    * Represents a module and its states. This is a kernel intern representation.
43    *
44    * @author Michael Meyling
45    */
 
46    public class DefaultKernelQedeqBo implements KernelQedeqBo {
47   
48    /** Internal kernel services. */
49    private final InternalKernelServices services;
50   
51    /** Address and module specification. */
52    private final ModuleAddress address;
53   
54    /** Loaded QEDEQ module. */
55    private QedeqVo qedeq;
56   
57    /** Required QEDEQ modules. */
58    private KernelModuleReferenceList required;
59   
60    /** Dependent QEDEQ modules. */
61    private KernelModuleReferenceList dependent;
62   
63    /** Predicate and function constant existence checker. */
64    private ModuleConstantsExistenceChecker checker;
65   
66    /** Labels for this module. */
67    private ModuleLabels labels;
68   
69    /** Loader used for loading this object. */
70    private QedeqFileDao loader;
71   
72    /** State change manager. */
73    private final StateManager stateManager;
74   
75    /**
76    * Creates new module properties.
77    *
78    * @param services Internal kernel services.
79    * @param address Module address (not <code>null</code>).
80    * @throws NullPointerException <code>address</code> is null.
81    */
 
82  172 toggle public DefaultKernelQedeqBo(final InternalKernelServices services,
83    final ModuleAddress address) {
84  172 this.services = services;
85  172 this.address = address;
86  172 if (address == null) {
87  1 throw new NullPointerException("ModuleAddress must not be null");
88    }
89  171 required = new KernelModuleReferenceList();
90  171 dependent = new KernelModuleReferenceList();
91  171 stateManager = new StateManager(this);
92    }
93   
94    /**
95    * Set loader used for loading this object.
96    *
97    * @param loader Responsible loader.
98    */
 
99  161 toggle public void setQedeqFileDao(final QedeqFileDao loader) {
100  161 this.loader = loader;
101    }
102   
103    /**
104    * Get loader used to load this object.
105    *
106    * @return Loader.
107    */
 
108  0 toggle public QedeqFileDao getLoader() {
109  0 return this.loader;
110    }
111   
 
112  70 toggle public boolean hasBasicFailures() {
113  70 return stateManager.hasBasicFailures();
114    }
115   
 
116  1206 toggle public boolean hasErrors() {
117  1206 return stateManager.hasErrors();
118    }
119   
 
120  0 toggle public boolean hasWarnings() {
121  0 return stateManager.hasWarnings();
122    }
123   
 
124  3788 toggle public ModuleAddress getModuleAddress() {
125  3788 return address;
126    }
127   
128    /**
129    * Get internal kernel services.
130    *
131    * @return Internal kernel services.
132    */
 
133  161 toggle public InternalKernelServices getKernelServices() {
134  161 return this.services;
135    }
136   
137    /**
138    * Set completeness percentage.
139    *
140    * @param completeness Completeness of loading into memory.
141    */
 
142  0 toggle public void setLoadingCompleteness(final int completeness) {
143  0 stateManager.setLoadingCompleteness(completeness);
144    }
145   
 
146  0 toggle public int getLoadingCompleteness() {
147  0 return stateManager.getLoadingCompleteness();
148    }
149   
150    /**
151    * Delete QEDEQ module. Invalidates all dependent modules.
152    */
 
153  0 toggle public void delete() {
154  0 stateManager.delete();
155    }
156   
157    /**
158    * Set loading progress module state.
159    *
160    * @param state Module loading state. Must not be <code>null</code>.
161    * @throws IllegalStateException State is a failure state or module loaded state.
162    */
 
163  306 toggle public void setLoadingProgressState(final LoadingState state) {
164  306 stateManager.setLoadingProgressState(state);
165    }
166   
167    /**
168    * Set failure module state.
169    *
170    * @param state Module loading state. Must not be <code>null</code>.
171    * @param e Exception that occurred during loading. Must not be <code>null</code>.
172    * @throws IllegalArgumentException <code>state</code> is no failure state
173    */
 
174  23 toggle public void setLoadingFailureState(final LoadingState state,
175    final SourceFileExceptionList e) {
176  23 stateManager.setLoadingFailureState(state, e);
177    }
178   
 
179  186 toggle public LoadingState getLoadingState() {
180  186 return stateManager.getLoadingState();
181    }
182   
 
183  545 toggle public boolean isLoaded() {
184  545 return stateManager.isLoaded();
185    }
186   
187    /**
188    * Set loading state to "loaded". Also puts <code>null</code> to {@link #getLabels()}.
189    *
190    * @param qedeq This module was loaded. Must not be <code>null</code>.
191    * @param labels Module labels.
192    * @throws NullPointerException One argument was <code>null</code>.
193    */
 
194  159 toggle public void setLoaded(final QedeqVo qedeq, final ModuleLabels labels) {
195  159 stateManager.setLoaded(qedeq, labels);
196    }
197   
 
198  1036 toggle public Qedeq getQedeq() {
199  1036 return this.qedeq;
200    }
201   
202    /**
203    * Set dependency progress module state.
204    *
205    * @param state Module state. Must not be <code>null</code>.
206    * @throws IllegalStateException Module is not yet loaded.
207    * @throws IllegalArgumentException <code>state</code> is failure state or loaded required
208    * state.
209    * @throws NullPointerException <code>state</code> is <code>null</code>.
210    */
 
211  164 toggle public void setDependencyProgressState(final DependencyState state) {
212  164 stateManager.setDependencyProgressState(state);
213    }
214   
215    /**
216    * Set failure module state.
217    *
218    * @param state Module dependency state. Must not be <code>null</code>.
219    * @param e Exception that occurred during loading. Must not be <code>null</code>.
220    * @throws IllegalStateException Module is not yet loaded.
221    * @throws IllegalArgumentException <code>state</code> is no failure state.
222    * @throws NullPointerException <code>state</code> is <code>null</code>.
223    */
 
224  50 toggle public void setDependencyFailureState(final DependencyState state,
225    final SourceFileExceptionList e) {
226  50 stateManager.setDependencyFailureState(state, e);
227    }
228   
 
229  492 toggle public DependencyState getDependencyState() {
230  492 return stateManager.getDependencyState();
231    }
232   
233    /**
234    * Set loaded required requirements state.
235    *
236    * @param list URLs of all referenced modules. Must not be <code>null</code>.
237    * @throws IllegalStateException Module is not yet loaded.
238    */
 
239  126 toggle public void setLoadedRequiredModules(final KernelModuleReferenceList list) {
240  126 stateManager.setLoadedRequiredModules(list);
241    }
242   
 
243  1366 toggle public ModuleReferenceList getRequiredModules() {
244  1366 return getKernelRequiredModules();
245    }
246   
247    /**
248    * Get labels and URLs of all referenced modules.
249    *
250    * @return URLs of all referenced modules.
251    */
 
252  2757 toggle public KernelModuleReferenceList getKernelRequiredModules() {
253  2757 return required;
254    }
255   
 
256  427 toggle public boolean hasLoadedRequiredModules() {
257  427 return stateManager.hasLoadedRequiredModules();
258    }
259   
260    /**
261    * Get labels and URLs of all directly dependent modules.
262    *
263    * @return URLs of all referenced modules.
264    */
 
265  825 toggle public KernelModuleReferenceList getDependentModules() {
266  825 return dependent;
267    }
268   
269    /**
270    * Set logic checked state. Also set the predicate and function existence checker.
271    *
272    * @param checker Checks if a predicate or function constant is defined.
273    */
 
274  79 toggle public void setChecked(final ModuleConstantsExistenceChecker checker) {
275  79 stateManager.setChecked(checker);
276    }
277   
 
278  276 toggle public boolean isChecked() {
279  276 return stateManager.isChecked();
280    }
281   
282    /**
283    * Set loading progress module state. Must not be <code>null</code>.
284    *
285    * @param state module state
286    */
 
287  194 toggle public void setLogicalProgressState(final LogicalState state) {
288  194 stateManager.setLogicalProgressState(state);
289    }
290   
291    /**
292    * Set failure module state.
293    *
294    * @param state module state
295    * @param e Exception that occurred during loading.
296    * @throws IllegalArgumentException <code>state</code> is no failure state
297    */
 
298  20 toggle public void setLogicalFailureState(final LogicalState state,
299    final SourceFileExceptionList e) {
300  20 stateManager.setLogicalFailureState(state, e);
301    }
302   
 
303  8 toggle public LogicalState getLogicalState() {
304  8 return stateManager.getLogicalState();
305    }
306   
 
307  114 toggle public SourceFileExceptionList getErrors() {
308  114 return stateManager.getErrors();
309    }
310   
 
311  23 toggle public SourceFileExceptionList getWarnings() {
312  23 return stateManager.getWarnings();
313    }
314   
 
315  1101 toggle public String getStateDescription() {
316  1101 return stateManager.getStateDescription();
317    }
318   
 
319  24 toggle public String getName() {
320  24 if (address == null) {
321  0 return "null";
322    }
323  24 return address.getName();
324    }
325   
 
326  0 toggle public String getRuleVersion() {
327  0 if (address == null || qedeq == null
328    || qedeq.getHeader() == null
329    || qedeq.getHeader().getSpecification() == null
330    || qedeq.getHeader().getSpecification().getRuleVersion() == null) {
331  0 return "";
332    }
333  0 return qedeq.getHeader().getSpecification().getRuleVersion();
334    }
335   
 
336  1824 toggle public String getUrl() {
337  1824 if (this.address == null) {
338  0 return null;
339    }
340  1824 return this.address.getUrl();
341    }
342   
343    /**
344    * Set label references for QEDEQ module.
345    *
346    * @param labels Label references.
347    */
 
348  474 toggle public void setLabels(final ModuleLabels labels) {
349  474 this.labels = labels;
350    }
351   
 
352  742 toggle public ModuleLabels getLabels() {
353  742 return labels;
354    }
355   
356    /**
357    * Create exception out of {@link ModuleDataException}.
358    *
359    * @param plugin This plugin generated the error.
360    * @param exception Take this exception.
361    * @return Newly created instance.
362    */
 
363  2 toggle public SourceFileExceptionList createSourceFileExceptionList(final Plugin plugin,
364    final ModuleDataException exception) {
365  2 final SourceFileException e = new SourceFileException(plugin, exception,
366    createSourceArea(qedeq, exception.getContext()), loader.createSourceArea(qedeq,
367    exception.getReferenceContext()));
368  2 final DefaultSourceFileExceptionList list = new DefaultSourceFileExceptionList(e);
369  2 return list;
370    }
371   
372    /**
373    * Create exception out of {@link ModuleDataException}.
374    *
375    * @param plugin This plugin generated the error.
376    * @param exception Take this exception.
377    * @param qedeq Take this QEDEQ source. (This might not be accessible via
378    * {@link #getQedeq()}.
379    * @return Newly created instance.
380    */
 
381  0 toggle public SourceFileExceptionList createSourceFileExceptionList(final Plugin plugin,
382    final ModuleDataException exception, final Qedeq qedeq) {
383  0 final SourceFileException e = new SourceFileException(plugin, exception,
384    createSourceArea(qedeq, exception.getContext()), loader.createSourceArea(qedeq,
385    exception.getReferenceContext()));
386  0 final DefaultSourceFileExceptionList list = new DefaultSourceFileExceptionList(e);
387  0 return list;
388    }
389   
 
390  82 toggle public SourceFileException createSourceFileException(final Plugin plugin, final ModuleDataException
391    exception) {
392  82 final SourceFileException e = new SourceFileException(plugin, exception,
393    createSourceArea(qedeq, exception.getContext()), loader.createSourceArea(qedeq,
394    exception.getReferenceContext()));
395  82 return e;
396    }
397   
398    /**
399    * Create area in source file for QEDEQ module context.
400    *
401    * @param qedeq Look at this QEDEQ module.
402    * @param context Search for this context.
403    * @return Created file area. Maybe <code>null</code>.
404    */
 
405  84 toggle public SourceArea createSourceArea(final Qedeq qedeq, final ModuleContext context) {
406  84 return loader.createSourceArea(qedeq, context);
407    }
408   
409    /**
410    * Set {@link QedeqVo}. Doesn't do any status handling. Only for internal use.
411    *
412    * @param qedeq Set this value.
413    */
 
414  628 toggle public void setQedeqVo(final QedeqVo qedeq) {
415  628 this.qedeq = qedeq;
416    }
417   
418    /**
419    * Get {@link StateManager}. Only for internal use.
420    *
421    * @return StateManager
422    */
 
423  0 toggle protected StateManager getStateManager() {
424  0 return this.stateManager;
425    }
426   
427    /**
428    * Get the predicate and function existence checker. Is only not <code>null</code>
429    * if logic was successfully checked.
430    *
431    * @return Checker. Checks if a predicate or function constant is defined.
432    */
 
433  2059 toggle public ModuleConstantsExistenceChecker getExistenceChecker() {
434  2059 return checker;
435    }
436   
437    /**
438    * Set {@link ModuleConstantsExistenceChecker}. Doesn't do any status handling. Only for
439    * internal use.
440    *
441    * @param checker Set this checker.
442    */
 
443  79 toggle protected void setExistenceChecker(final ModuleConstantsExistenceChecker checker) {
444  79 this.checker = checker;
445    }
446   
 
447  644 toggle public int hashCode() {
448  644 return (getModuleAddress() == null ? 0 : getModuleAddress().hashCode());
449    }
450   
 
451  395 toggle public boolean equals(final Object obj) {
452  395 if (obj instanceof DefaultKernelQedeqBo) {
453  391 return EqualsUtility.equals(((DefaultKernelQedeqBo) obj).getModuleAddress(),
454    this.getModuleAddress());
455    }
456  4 return false;
457    }
458   
 
459  161 toggle public String toString() {
460  161 return address.getUrl();
461    }
462   
 
463  24 toggle public void addPluginErrors(final PluginBo plugin, final SourceFileExceptionList errors,
464    final SourceFileExceptionList warnings) {
465  24 stateManager.addPluginResults(plugin, errors, warnings);
466    }
467   
468    }
 
CloverReport generated by Clover Code Coverage v2.3.1
Sat Sep 18 2010 04:09:52 UTC.		   Clover: Open Source License registered to qedeq.org .