Coverage Report - org.apache.commons.scxml.model.State

Classes in this File Line Coverage Branch Coverage Complexity
State
98% 
100% 
1.5

 1  
 /*
 2  
  *
 3  
  *   Copyright 2005-2006 The Apache Software Foundation.
 4  
  *
 5  
  *  Licensed under the Apache License, Version 2.0 (the "License");
 6  
  *  you may not use this file except in compliance with the License.
 7  
  *  You may obtain a copy of the License at
 8  
  *
 9  
  *      http://www.apache.org/licenses/LICENSE-2.0
 10  
  *
 11  
  *  Unless required by applicable law or agreed to in writing, software
 12  
  *  distributed under the License is distributed on an "AS IS" BASIS,
 13  
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 14  
  *  See the License for the specific language governing permissions and
 15  
  *  limitations under the License.
 16  
  *
 17  
  */
 18  
 package org.apache.commons.scxml.model;
 19  
 
 20  
 import java.util.ArrayList;
 21  
 import java.util.HashMap;
 22  
 import java.util.Iterator;
 23  
 import java.util.List;
 24  
 import java.util.Map;
 25  
 
 26  
 /**
 27  
  * The class in this SCXML object model that corresponds to the
 28  
  * <state> SCXML element.
 29  
  *
 30  
  */
 31  
 public class State extends TransitionTarget {
 32  
 
 33  
     /**
 34  
      * The Map containing immediate children of this State, keyed by
 35  
      * their IDs. Incompatible with the parallel or invoke property.
 36  
      */
 37  
     private Map children;
 38  
 
 39  
     /**
 40  
      * The Parallel child, which defines a set of parallel substates.
 41  
      * May occur 0 or 1 times. Incompatible with the state or invoke property.
 42  
      */
 43  
     private Parallel parallel;
 44  
 
 45  
     /**
 46  
      * The Invoke child, which defines an external process that should
 47  
      * be invoked, immediately after the onentry executable content,
 48  
      * and the transitions become candidates after the invoked
 49  
      * process has completed its execution.
 50  
      * May occur 0 or 1 times. Incompatible with the state or parallel
 51  
      * property.
 52  
      */
 53  
     private Invoke invoke;
 54  
 
 55  
     /**
 56  
      * Boolean property indicating whether this is a final state or not.
 57  
      * Default value is false . Final states may not have substates or
 58  
      * outgoing transitions.
 59  
      */
 60  
     private boolean isFinal;
 61  
 
 62  
     /**
 63  
      * A child which identifies initial state for state machines that
 64  
      * have substates.
 65  
      */
 66  
     private Initial initial;
 67  
 
 68  
     /**
 69  
      * A map of outgoing Transitions from this state.
 70  
      */
 71  
     private Map transitions;
 72  
 
 73  
     /**
 74  
      * List of history states owned by a given state (applies to non-leaf
 75  
      * states).
 76  
      */
 77  
     private List history;
 78  
 
 79  
     /**
 80  
      * Applies to composite states only. If one of its final children is
 81  
      * active, its parent is marked done. This property is reset upon
 82  
      * re-entry.
 83  
      */
 84  319
     private boolean done = false;
 85  
 
 86  
     /**
 87  
      * Constructor.
 88  
      */
 89  319
     public State() {
 90  319
         this.children = new HashMap();
 91  319
         this.transitions = new HashMap();
 92  319
         this.history = new ArrayList();
 93  319
     }
 94  
 
 95  
     /**
 96  
      * Is this state a "final" state.
 97  
      *
 98  
      * @return boolean Returns the isFinal.
 99  
      */
 100  
     public final boolean getIsFinal() {
 101  225
         return isFinal;
 102  
     }
 103  
 
 104  
     /**
 105  
      * Set whether this is a "final" state.
 106  
      *
 107  
      * @param isFinal
 108  
      *            The isFinal to set.
 109  
      */
 110  
     public final void setIsFinal(final boolean isFinal) {
 111  46
         this.isFinal = isFinal;
 112  46
     }
 113  
 
 114  
     /**
 115  
      * Get the Parallel child (may be null).
 116  
      *
 117  
      * @return Parallel Returns the parallel.
 118  
      */
 119  
     public final Parallel getParallel() {
 120  226
         return parallel;
 121  
     }
 122  
 
 123  
     /**
 124  
      * Set the Parallel child.
 125  
      *
 126  
      * @param parallel
 127  
      *            The parallel to set.
 128  
      */
 129  
     public final void setParallel(final Parallel parallel) {
 130  8
         this.parallel = parallel;
 131  8
     }
 132  
 
 133  
     /**
 134  
      * Get the Invoke child (may be null).
 135  
      *
 136  
      * @return Invoke Returns the invoke.
 137  
      */
 138  
     public final Invoke getInvoke() {
 139  345
         return invoke;
 140  
     }
 141  
 
 142  
     /**
 143  
      * Set the Invoke child.
 144  
      *
 145  
      * @param invoke
 146  
      *            The invoke to set.
 147  
      */
 148  
     public final void setInvoke(final Invoke invoke) {
 149  1
         this.invoke = invoke;
 150  1
     }
 151  
 
 152  
     /**
 153  
      * Get the initial state.
 154  
      *
 155  
      * @return Initial Returns the initial state.
 156  
      */
 157  
     public final Initial getInitial() {
 158  258
         return initial;
 159  
     }
 160  
 
 161  
     /**
 162  
      * Set the initial state.
 163  
      *
 164  
      * @param target
 165  
      *            The target to set.
 166  
      */
 167  
     public final void setInitial(final Initial target) {
 168  40
         this.initial = target;
 169  40
     }
 170  
 
 171  
     /**
 172  
      * Get the map of all outgoing transitions from this state.
 173  
      *
 174  
      * @return Map Returns the transitions Map.
 175  
      */
 176  
     public final Map getTransitions() {
 177  226
         return transitions;
 178  
     }
 179  
 
 180  
     /**
 181  
      * Get the list of all outgoing transitions from this state, that
 182  
      * will be candidates for being fired on the given event.
 183  
      *
 184  
      * @param event The event
 185  
      * @return List Returns the candidate transitions for given event
 186  
      */
 187  
     public final List getTransitionsList(final String event) {
 188  3
         Object candidateTransitions = transitions.get(event);
 189  3
         if (candidateTransitions == null) {
 190  1
             return null;
 191  
         }
 192  2
         return (List) candidateTransitions;
 193  
     }
 194  
 
 195  
     /**
 196  
      * Add a transition to the map of all outgoing transitions for
 197  
      * this state.
 198  
      *
 199  
      * @param transition
 200  
      *            The transitions to set.
 201  
      */
 202  
     public final void addTransition(final Transition transition) {
 203  163
         String event = transition.getEvent();
 204  163
         if (!transitions.containsKey(event)) {
 205  156
             List eventTransitions = new ArrayList();
 206  156
             eventTransitions.add(transition);
 207  156
             transitions.put(event, eventTransitions);
 208  
         } else {
 209  7
             ((List) transitions.get(event)).add(transition);
 210  
         }
 211  163
     }
 212  
 
 213  
     /**
 214  
      * Get the map of child states (may be empty).
 215  
      *
 216  
      * @return Map Returns the children.
 217  
      */
 218  
     public final Map getChildren() {
 219  226
         return children;
 220  
     }
 221  
 
 222  
     /**
 223  
      * Add a child state.
 224  
      *
 225  
      * @param state
 226  
      *            a child state
 227  
      */
 228  
     public final void addChild(final State state) {
 229  95
         this.children.put(state.getId(), state);
 230  95
         state.setParent(this);
 231  95
     }
 232  
 
 233  
     /**
 234  
      * Get the outgoing transitions for this state as a java.util.List.
 235  
      *
 236  
      * @return List Returns the transitions (as a list). TODO - Check in next
 237  
      *         iteration whether both methods need to be retained.
 238  
      */
 239  
     public final List getTransitionsList() {
 240  
         // Each call creates a new List, this will change once TO-DO is handled
 241  384
         List transitionsList = new ArrayList();
 242  384
         for (Iterator iter = transitions.keySet().iterator();
 243  700
                 iter.hasNext();) {
 244  316
             transitionsList.addAll((List) transitions.get(iter.next()));
 245  
         }
 246  384
         return transitionsList;
 247  
     }
 248  
 
 249  
     /**
 250  
      * This method is used by XML digester.
 251  
      *
 252  
      * @param h
 253  
      *            History pseudo state
 254  
      */
 255  
     public final void addHistory(final History h) {
 256  6
         history.add(h);
 257  6
     }
 258  
 
 259  
     /**
 260  
      * Does this state have a history pseudo state.
 261  
      *
 262  
      * @return boolean true if a given state contains at least one
 263  
      *                 history pseudo state
 264  
      */
 265  
     public final boolean hasHistory() {
 266  107
         return (!history.isEmpty());
 267  
     }
 268  
 
 269  
     /**
 270  
      * Get the list of history pseudo states for this state.
 271  
      *
 272  
      * @return a list of all history pseudo states contained by a given state
 273  
      *         (can be empty)
 274  
      * @see #hasHistory()
 275  
      */
 276  
     public final List getHistory() {
 277  233
         return history;
 278  
     }
 279  
 
 280  
     /**
 281  
      * Check whether this is a simple (leaf) state (UML terminology).
 282  
      *
 283  
      * @return true if this is a simple state, otherwise false
 284  
      */
 285  
     public final boolean isSimple() {
 286  178
         if (parallel == null && children.isEmpty()) {
 287  133
             return true;
 288  
         }
 289  45
         return false;
 290  
     }
 291  
 
 292  
     /**
 293  
      * Check whether this is a composite state (UML terminology).
 294  
      *
 295  
      * @return true if this is a composite state, otherwise false
 296  
      */
 297  
     public final boolean isComposite() {
 298  3
         if (parallel == null && children.isEmpty()) {
 299  1
             return false;
 300  
         }
 301  2
         return true;
 302  
     }
 303  
 
 304  
     /**
 305  
      * Checks whether it is a region state (directly nested to parallel - UML
 306  
      * terminology).
 307  
      *
 308  
      * @return true if this is a region state, otherwise false
 309  
      * @see Parallel
 310  
      */
 311  
     public final boolean isRegion() {
 312  187
         if (getParent() instanceof Parallel) {
 313  13
             return true;
 314  
         }
 315  174
         return false;
 316  
     }
 317  
 
 318  
     /**
 319  
      * Checks whether it is a orthogonal state, that is, it owns a parallel
 320  
      * (UML terminology).
 321  
      *
 322  
      * @return true if this is a orthogonal state, otherwise false
 323  
      */
 324  
     public final boolean isOrthogonal() {
 325  40
         if (parallel != null) {
 326  4
             return true;
 327  
         }
 328  36
         return false;
 329  
     }
 330  
 
 331  
     /**
 332  
      * In case this is a parallel state, check if one its final states
 333  
      * is active.
 334  
      *
 335  
      * @return Returns the done.
 336  
      */
 337  
     public final boolean isDone() {
 338  0
         return done;
 339  
     }
 340  
 
 341  
     /**
 342  
      * Update the done property, which is set if this is a parallel state,
 343  
      * and one its final states is active.
 344  
      *
 345  
      * @param done The done to set.
 346  
      */
 347  
     public final void setDone(final boolean done) {
 348  134
         this.done = done;
 349  134
     }
 350  
 }
 351