Clover Coverage Report
Coverage timestamp: Sa Aug 2 2008 13:56:27 CEST
../../../../../img/srcFileCovDistChart6.png 69% of files have more coverage
204   485   66   10,2
80   330   0,32   20
20     3,3  
1    
 
  StateManager       Line # 43 204 66 53,6% 0.5361842
 
  (43)
 
1    /* $Id: StateManager.java,v 1.1 2008/07/26 07:58:28 m31 Exp $
2    *
3    * This file is part of the project "Hilbert II" - http://www.qedeq.org
4    *
5    * Copyright 2000-2008, Michael Meyling <mime@qedeq.org>.
6    *
7    * "Hilbert II" is free software; you can redistribute
8    * it and/or modify it under the terms of the GNU General Public
9    * License as published by the Free Software Foundation; either
10    * version 2 of the License, or (at your option) any later version.
11    *
12    * This program is distributed in the hope that it will be useful,
13    * but WITHOUT ANY WARRANTY; without even the implied warranty of
14    * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15    * GNU General Public License for more details.
16    */
17   
18    package org.qedeq.kernel.bo.service;
19   
20    import java.util.ArrayList;
21    import java.util.List;
22   
23    import org.qedeq.base.trace.Trace;
24    import org.qedeq.base.utility.StringUtility;
25    import org.qedeq.kernel.bo.log.ModuleEventLog;
26    import org.qedeq.kernel.bo.logic.wf.ExistenceChecker;
27    import org.qedeq.kernel.bo.module.KernelModuleReferenceList;
28    import org.qedeq.kernel.common.DependencyState;
29    import org.qedeq.kernel.common.LoadingState;
30    import org.qedeq.kernel.common.LogicalState;
31    import org.qedeq.kernel.common.ModuleDataException;
32    import org.qedeq.kernel.common.ModuleLabels;
33    import org.qedeq.kernel.common.SourceFileExceptionList;
34    import org.qedeq.kernel.dto.module.QedeqVo;
35   
36   
37    /**
38    * Changes the states of {@link org.qedeq.kernel.bo.service.DefaultKernelQedeqBo}s.
39    *
40    * @version $Revision: 1.1 $
41    * @author Michael Meyling
42    */
 
43    public class StateManager {
44   
45    /** This class. */
46    private static final Class CLASS = StateManager.class;
47   
48    /** Main BO to care about. */
49    private final DefaultKernelQedeqBo bo;
50   
 
51  131 toggle StateManager(final DefaultKernelQedeqBo bo) {
52  131 this.bo = bo;
53    }
54   
55    /**
56    * Set completeness percentage.
57    *
58    * @param completeness Completeness of loading into memory.
59    */
 
60  0 toggle public void setLoadingCompleteness(final int completeness) {
61  0 bo.setLoadingCompleteness(completeness);
62    }
63   
64    /**
65    * Delete QEDEQ module. Invalidates all dependent modules.
66    */
 
67  0 toggle public void delete() {
68  0 checkIfDeleted();
69  0 invalidateOtherDependentModulesToLoaded();
70  0 bo.setLoadingState(LoadingState.STATE_DELETED);
71  0 bo.setQedeqVo(null);
72  0 bo.getKernelRequiredModules().clear();
73  0 bo.getDependentModules().clear();
74  0 bo.setLabels(null);
75  0 bo.setDependencyState(DependencyState.STATE_UNDEFINED);
76  0 bo.setLogicalState(LogicalState.STATE_UNCHECKED);
77  0 bo.setException(null);
78  0 ModuleEventLog.getInstance().removeModule(bo);
79    }
80   
81    /**
82    * Set loading progress module state.
83    *
84    * @param state Module loading state. Must not be <code>null</code>.
85    * @throws IllegalStateException State is a failure state or module loaded state.
86    */
 
87  230 toggle public void setLoadingProgressState(final LoadingState state) {
88  230 checkIfDeleted();
89  230 if (state == LoadingState.STATE_LOADED) {
90  1 throw new IllegalArgumentException(
91    "this state could only be set by calling method setLoaded");
92    }
93  228 if (state != LoadingState.STATE_DELETED && state.isFailure()) {
94  3 throw new IllegalArgumentException(
95    "this is a failure state, call setLoadingFailureState for " + state);
96    }
97    // if module has no loading state we give him one before creating an event
98  225 if (bo.getLoadingState() == LoadingState.STATE_UNDEFINED) {
99  113 bo.setLoadingState(state);
100  113 ModuleEventLog.getInstance().addModule(bo);
101    }
102  225 if (state == LoadingState.STATE_LOADING_FROM_BUFFER) {
103  11 invalidateOtherDependentModulesToLoaded();
104    }
105  225 if (state == LoadingState.STATE_DELETED) {
106  0 throw new IllegalArgumentException(
107    "call delete for " + state);
108    }
109  225 bo.setLoadingState(state);
110  225 bo.setQedeqVo(null);
111  225 bo.getKernelRequiredModules().clear();
112  225 bo.getDependentModules().clear();
113  225 bo.setLabels(null);
114  225 bo.setDependencyState(DependencyState.STATE_UNDEFINED);
115  225 bo.setLogicalState(LogicalState.STATE_UNCHECKED);
116  225 bo.setException(null);
117  225 ModuleEventLog.getInstance().stateChanged(bo);
118    }
119   
120    /**
121    * Set failure module state.
122    *
123    * @param state Module loading state. Must not be <code>null</code>.
124    * @param e Exception that occurred during loading. Must not be <code>null</code>.
125    * @throws IllegalArgumentException <code>state</code> is no failure state
126    */
 
127  21 toggle public void setLoadingFailureState(final LoadingState state,
128    final SourceFileExceptionList e) {
129  21 checkIfDeleted();
130  19 if (!state.isFailure()) {
131  6 throw new IllegalArgumentException(
132    "this is no failure state, call setLoadingProgressState");
133    }
134    // if module has no loading state we give him one before creating an event
135  13 if (bo.getLoadingState() == LoadingState.STATE_UNDEFINED) {
136  3 bo.setLoadingState(state);
137  3 ModuleEventLog.getInstance().addModule(bo);
138    }
139  13 invalidateOtherDependentModulesToLoaded();
140  13 bo.setQedeqVo(null);
141  13 bo.getKernelRequiredModules().clear();
142  13 bo.getDependentModules().clear();
143  13 bo.setLabels(null);
144  13 bo.setLoadingState(state);
145  13 bo.setDependencyState(DependencyState.STATE_UNDEFINED);
146  13 bo.setLogicalState(LogicalState.STATE_UNCHECKED);
147  13 bo.setException(e);
148  13 if (e == null) {
149  1 throw new NullPointerException("Exception must not be null");
150    }
151  12 ModuleEventLog.getInstance().stateChanged(bo);
152    }
153   
154    /**
155    * Set loading state to "loaded". Also puts <code>null</code> to
156    * {@link DefaultKernelQedeqBo#getLabels()}.
157    *
158    * @param qedeq This module was loaded. Must not be <code>null</code>.
159    * @param labels Module labels.
160    * @throws NullPointerException One argument was <code>null</code>.
161    */
 
162  122 toggle public void setLoaded(final QedeqVo qedeq, final ModuleLabels labels) {
163  122 checkIfDeleted();
164  122 if (qedeq == null) {
165  0 throw new NullPointerException("Qedeq is null");
166    }
167  122 invalidateOtherDependentModulesToLoaded();
168  122 bo.setLoadingState(LoadingState.STATE_LOADED);
169  122 bo.setQedeqVo(qedeq);
170  122 bo.getKernelRequiredModules().clear();
171  122 bo.getDependentModules().clear();
172  122 bo.setLabels(labels);
173  122 bo.setDependencyState(DependencyState.STATE_UNDEFINED);
174  122 bo.setLogicalState(LogicalState.STATE_UNCHECKED);
175  122 bo.setException(null);
176  122 ModuleEventLog.getInstance().stateChanged(bo);
177    }
178   
179    /**
180    * Set dependency progress module state.
181    *
182    * @param state Module state. Must not be <code>null</code>.
183    * @throws IllegalStateException Module is not yet loaded.
184    * @throws IllegalArgumentException <code>state</code> is failure state or loaded required
185    * state.
186    * @throws NullPointerException <code>state</code> is <code>null</code>.
187    */
 
188  159 toggle public void setDependencyProgressState(final DependencyState state) {
189  159 checkIfDeleted();
190  159 if (!bo.isLoaded() && state != DependencyState.STATE_UNDEFINED) {
191  0 throw new IllegalStateException("module is not yet loaded");
192    }
193  159 if (state.isFailure()) {
194  0 throw new IllegalArgumentException(
195    "this is a failure state, call setDependencyFailureState");
196    }
197  159 if (state == DependencyState.STATE_LOADED_REQUIRED_MODULES) {
198  0 throw new IllegalArgumentException(
199    "this state could only be set by calling method setLoadedRequiredModules");
200    }
201  159 if (state == DependencyState.STATE_LOADING_REQUIRED_MODULES) {
202  158 invalidateOtherDependentModulesToLoaded();
203    }
204  159 bo.setLogicalState(LogicalState.STATE_UNCHECKED);
205  159 bo.setDependencyState(state);
206  159 bo.getKernelRequiredModules().clear();
207  159 bo.setException(null);
208  159 ModuleEventLog.getInstance().stateChanged(bo);
209    }
210   
211    /**
212    * Set failure module state.
213    *
214    * @param state Module dependency state. Must not be <code>null</code>.
215    * @param e Exception that occurred during loading. Must not be <code>null</code>.
216    * @throws IllegalStateException Module is not yet loaded.
217    * @throws IllegalArgumentException <code>state</code> is no failure state.
218    * @throws NullPointerException <code>state</code> is <code>null</code>.
219    */
 
220  81 toggle public void setDependencyFailureState(final DependencyState state,
221    final SourceFileExceptionList e) {
222  81 checkIfDeleted();
223  81 if (!bo.isLoaded()) {
224  2 throw new IllegalStateException("module is not yet loaded");
225    }
226  79 if (!state.isFailure()) {
227  4 throw new IllegalArgumentException(
228    "this is no failure state, call setLoadingProgressState");
229    }
230  75 invalidateOtherDependentModulesToLoadedRequired();
231  75 bo.setDependencyState(state);
232  75 bo.setException(e);
233  75 if (e == null) {
234  1 throw new NullPointerException("Exception must not be null");
235    }
236  74 ModuleEventLog.getInstance().stateChanged(bo);
237    }
238   
239    /**
240    * Reset all (recursive) dependent modules (if any) to state loaded.
241    */
 
242  304 toggle private void invalidateOtherDependentModulesToLoaded() {
243  304 final String method = "invalidateOtherDependModulesToLoaded";
244  304 Trace.begin(CLASS, this, method);
245  304 Trace.param(CLASS, this, method, "bo", bo);
246  304 if (bo.hasLoadedRequiredModules()) {
247  0 final KernelModuleReferenceList dependent = bo.getDependentModules();
248  0 Trace.trace(CLASS, this, method, "begin list of dependent modules");
249    // remember dependent modules
250  0 final List list = new ArrayList();
251  0 for (int i = 0; i < dependent.size(); i++) {
252  0 Trace.param(CLASS, this, method, "" + i, dependent.getKernelQedeqBo(i));
253  0 list.add(dependent.getKernelQedeqBo(i));
254    }
255  0 Trace.trace(CLASS, this, method, "end list of dependent modules");
256  0 for (int i = 0; i < list.size(); i++) {
257  0 DefaultKernelQedeqBo ref = (DefaultKernelQedeqBo) list.get(i);
258    // work on it, if still in list of dependent modules
259  0 if (dependent.contains(ref)) {
260  0 ref.getStateManager().invalidateDependentModulesToLoaded();
261    }
262    }
263  0 list.clear();
264  0 dependent.clear();
265   
266  0 final KernelModuleReferenceList required = bo.getKernelRequiredModules();
267  0 for (int i = 0; i < required.size(); i++) {
268  0 DefaultKernelQedeqBo ref = (DefaultKernelQedeqBo) required.getKernelQedeqBo(i);
269  0 Trace.param(CLASS, this, method, "remove dependence from", ref);
270  0 ref.getDependentModules().remove(bo);
271    }
272  0 required.clear();
273    }
274  304 Trace.end(CLASS, this, method);
275    }
276   
277    /**
278    * Reset this and all (recursive) dependent modules (if any) to state loaded.
279    */
 
280  0 toggle private void invalidateDependentModulesToLoaded() {
281  0 final String method = "invalidateDependentModulesToLoaded";
282  0 Trace.begin(CLASS, this, method);
283  0 Trace.param(CLASS, this, method, "bo", bo);
284  0 if (bo.hasLoadedRequiredModules()) {
285  0 final KernelModuleReferenceList dependent = bo.getDependentModules();
286  0 Trace.trace(CLASS, this, method, "begin list of dependent modules");
287    // remember dependent modules
288  0 final List list = new ArrayList();
289  0 for (int i = 0; i < dependent.size(); i++) {
290  0 Trace.param(CLASS, this, method, "" + i, dependent.getKernelQedeqBo(i));
291  0 list.add(dependent.getKernelQedeqBo(i));
292    }
293  0 Trace.trace(CLASS, this, method, "end list of dependent modules");
294  0 for (int i = 0; i < list.size(); i++) {
295  0 DefaultKernelQedeqBo ref = (DefaultKernelQedeqBo) list.get(i);
296    // work on it, if still in list of dependent modules
297  0 if (dependent.contains(ref)) {
298  0 ref.getStateManager().invalidateDependentModulesToLoaded();
299    }
300    }
301  0 list.clear();
302  0 dependent.clear();
303   
304  0 final KernelModuleReferenceList required = bo.getKernelRequiredModules();
305  0 for (int i = 0; i < required.size(); i++) {
306  0 DefaultKernelQedeqBo ref = (DefaultKernelQedeqBo) required.getKernelQedeqBo(i);
307  0 Trace.param(CLASS, this, method, "remove dependence from", ref);
308  0 ref.getDependentModules().remove(bo);
309    }
310  0 required.clear();
311   
312  0 invalidateThisModule();
313  0 bo.setLoadingState(LoadingState.STATE_LOADED);
314  0 ModuleEventLog.getInstance().stateChanged(bo);
315    }
316  0 Trace.end(CLASS, this, method);
317    }
318   
319    /**
320    * Reset all (recursive) dependent modules (if any) to state loaded required.
321    */
 
322  199 toggle private void invalidateOtherDependentModulesToLoadedRequired() {
323  199 if (bo.isChecked()) {
324  0 final KernelModuleReferenceList dependent = bo.getDependentModules();
325  0 for (int i = 0; i < dependent.size(); i++) {
326  0 DefaultKernelQedeqBo ref = (DefaultKernelQedeqBo) dependent.getKernelQedeqBo(i);
327  0 ref.getStateManager().invalidateDependentModulesToLoadedRequired();
328    }
329    }
330    }
331   
332    /**
333    * Reset this and all (recursive) dependent modules (if any) to state loaded.
334    */
 
335  101 toggle private void invalidateDependentModulesToLoadedRequired() {
336  101 if (bo.isChecked()) {
337  0 final KernelModuleReferenceList dependent = bo.getDependentModules();
338  0 for (int i = 0; i < dependent.size(); i++) {
339  0 DefaultKernelQedeqBo ref = (DefaultKernelQedeqBo) dependent.getKernelQedeqBo(i);
340  0 ref.getStateManager().invalidateDependentModulesToLoadedRequired();
341    }
342  0 invalidateThisModule();
343  0 bo.setDependencyState(DependencyState.STATE_LOADED_REQUIRED_MODULES);
344  0 ModuleEventLog.getInstance().stateChanged(bo);
345    }
346    }
347   
 
348  0 toggle private void invalidateThisModule() {
349  0 bo.setLoadingState(LoadingState.STATE_LOADED);
350  0 bo.setDependencyState(DependencyState.STATE_UNDEFINED);
351  0 bo.setLogicalState(LogicalState.STATE_UNCHECKED);
352  0 bo.setException(null);
353    }
354   
355    /**
356    * Set loaded required requirements state.
357    *
358    * @param required URLs of all referenced modules. Must not be <code>null</code>.
359    * @throws IllegalStateException Module is not yet loaded.
360    */
 
361  90 toggle public void setLoadedRequiredModules(final KernelModuleReferenceList required) {
362  90 checkIfDeleted();
363  90 if (!bo.isLoaded()) {
364  0 throw new IllegalStateException(
365    "Required modules can only be set if module is loaded."
366    + "\"\nCurrently the status for the module"
367    + "\"" + bo.getName() + "\" is \"" + bo.getLoadingState() + "\"");
368    }
369  90 invalidateDependentModulesToLoadedRequired();
370   
371  159 for (int i = 0; i < required.size(); i++) {
372  69 DefaultKernelQedeqBo current = (DefaultKernelQedeqBo) required.getKernelQedeqBo(i);
373  69 try {
374  69 current.getDependentModules().add(required.getModuleContext(i),
375    required.getLabel(i), bo);
376    } catch (ModuleDataException me) { // should never happen
377  0 throw new RuntimeException(me);
378    }
379    }
380   
381   
382  90 bo.setDependencyState(DependencyState.STATE_LOADED_REQUIRED_MODULES);
383  90 bo.getKernelRequiredModules().set(required);
384  90 ModuleEventLog.getInstance().stateChanged(bo);
385    }
386   
387    /**
388    * Set logic checked state. Also set the predicate and function existence checker.
389    *
390    * @param checker Checks if a predicate or function constant is defined.
391    */
 
392  52 toggle public void setChecked(final ExistenceChecker checker) {
393  52 checkIfDeleted();
394  52 if (!bo.hasLoadedRequiredModules()) {
395  0 throw new IllegalStateException(
396    "Checked can only be set if all required modules are loaded."
397    + "\"\nCurrently the status for the module"
398    + "\"" + bo.getName() + "\" is \"" + bo.getLoadingState() + "\"");
399    }
400  52 bo.setLogicalState(LogicalState.STATE_CHECKED);
401  52 bo.setExistenceChecker(checker);
402  52 ModuleEventLog.getInstance().stateChanged(bo);
403    }
404   
405    /**
406    * Set loading progress module state. Must not be <code>null</code>.
407    *
408    * @param state module state
409    */
 
410  124 toggle public void setLogicalProgressState(final LogicalState state) {
411  124 if (bo.getDependencyState().getCode()
412    < DependencyState.STATE_LOADED_REQUIRED_MODULES.getCode()
413    && state != LogicalState.STATE_UNCHECKED) {
414  0 throw new IllegalArgumentException(
415    "this state could only be set if all required modules are loaded ");
416    }
417  124 if (state.isFailure()) {
418  0 throw new IllegalArgumentException(
419    "this is a failure state, call setLogicalFailureState");
420    }
421  124 if (state == LogicalState.STATE_CHECKED) {
422  0 throw new IllegalArgumentException(
423    "set with setChecked(ExistenceChecker)");
424    }
425  124 invalidateOtherDependentModulesToLoadedRequired();
426  124 bo.setException(null);
427  124 bo.setLogicalState(state);
428  124 ModuleEventLog.getInstance().stateChanged(bo);
429    }
430   
431    /**
432    * Set failure module state.
433    *
434    * @param state module state
435    * @param e Exception that occurred during loading.
436    * @throws IllegalArgumentException <code>state</code> is no failure state
437    */
 
438  11 toggle public void setLogicalFailureState(final LogicalState state,
439    final SourceFileExceptionList e) {
440  11 if ((!bo.isLoaded() || !bo.hasLoadedRequiredModules())
441    && state != LogicalState.STATE_UNCHECKED) {
442  0 throw new IllegalArgumentException(
443    "this state could only be set if all required modules are loaded ");
444    }
445  11 if (!state.isFailure()) {
446  0 throw new IllegalArgumentException(
447    "this is no failure state, call setLogicalProgressState");
448    }
449  11 invalidateDependentModulesToLoadedRequired();
450  11 bo.setLogicalState(state);
451  11 bo.setException(e);
452  11 ModuleEventLog.getInstance().stateChanged(bo);
453    }
454   
455    /**
456    * Checks if the current instance is already deleted.
457    *
458    * @throws IllegalStateException Module is already deleted.
459    */
 
460  755 toggle private void checkIfDeleted() {
461  755 if (bo.getLoadingState() == LoadingState.STATE_DELETED) {
462  0 throw new IllegalStateException("module is already deleted: " + bo.getUrl());
463    }
464    }
465   
466    /**
467    * Print the dependence tree to <code>System.out</code>.
468    */
 
469  0 toggle public void printDependencyTree() {
470  0 printDependencyTree(0);
471  0 System.out.println();
472    }
473   
 
474  0 toggle private void printDependencyTree(final int tab) {
475  0 System.out.println(StringUtility.getSpaces(tab) + bo.getName());
476  0 final int newTab = tab + bo.getName().length();
477  0 final KernelModuleReferenceList dependent = bo.getDependentModules();
478  0 for (int i = 0; i < dependent.size(); i++) {
479  0 DefaultKernelQedeqBo ref = (DefaultKernelQedeqBo) dependent.getKernelQedeqBo(i);
480  0 ref.getStateManager().printDependencyTree(newTab);
481    }
482    }
483   
484   
485    }