Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.apache.helix.model.util;
  
  /*
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements.  See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership.  The ASF licenses this file
   * to you under the Apache License, Version 2.0 (the
   * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 
Validator logic for a StateModelDefinition.

Usage:
StateModelDefinition stateModelDef = ...;
StateModelDefinitionValidator.isStateModelDefinitionValid(stateModelDef);
 
   private static final Logger _logger = Logger.getLogger(StateModelDefinitionValidator.class);
   private final StateModelDefinition _stateModelDef;
   private final List<String_statePriorityList;
   private final List<String_transitionPriorityList;
   private final Set<String_stateSet;

  
Instantiate a validator instance

Parameters:
stateModelDef the state model definition to validate
 
   private StateModelDefinitionValidator(StateModelDefinition stateModelDef) {
      = stateModelDef;
      = stateModelDef.getStatesPriorityList();
   }

  
Check if the StateModelDefinition passes all validation checks

Returns:
true if state model definition is valid, false otherwise
 
   public boolean isStateModelDefinitionValid() {
     // has a name
     if (.getId() == null || .getId().isEmpty()) {
       .error("State model does not have a name");
       return false;
     }
 
     // has an initial state
       
           .error("State model does not contain init state, statemodel:" + .getId());
       return false;
     }
 
     // has states
     if ( == null || .isEmpty()) {
       .error("CurrentState does not contain StatesPriorityList, state model : "
           + .getId());
       return false;
     }
 
     // initial state is a state
       .error("Defined states does not include the initial state, state model: "
           + .getId());
       return false;
     }
 
     // has a dropped state
       .error("Defined states does not include the DROPPED state, state model: "
           + .getId());
       return false;
     }
 
     // make sure individual checks all pass
        || !arePathsValid()) {
      return false;
    }
    return true;
  }

  
Check if state counts are properly defined for each state

Returns:
true if state counts valid, false otherwise
  private boolean areStateCountsValid() {
    for (String state : ) {
      // all states should have a count
      String count = .getNumInstancesPerState(state);
      if (count == null) {
        .error("State " + state + " needs an upper bound constraint, state model: "
            + .getId());
        return false;
      }
      // count should be a number, N, or R
      try {
        Integer.parseInt(count);
      } catch (NumberFormatException e) {
        if (!count.equals("N") && !count.equals("R")) {
          .error("State " + state + " has invalid count " + count + ", state model: "
              + .getId());
          return false;
        }
      }
    }
    return true;
  }

  
Check if the state transition priority list is properly formed

Returns:
true if the transition priority list is valid, false otherwise
  private boolean isTransitionPriorityListValid() {
    if ( != null) {
      for (String transition : ) {
        // ensure that transition is of form FROM-TO
        int index = transition.indexOf('-');
        int lastIndex = transition.indexOf('-');
        if (index <= 0 || index >= transition.length() - 1 || index != lastIndex) {
          .error("Transition " + transition + " is not of the form SRC-DEST, state model: "
              + .getId());
          return false;
        }
        // from and to states should be valid states
        String from = transition.substring(0, index);
        String to = transition.substring(index + 1);
        if (!.contains(from)) {
          .error("State " + from + " in " + transition
              + " is not a defined state, state model" + .getId());
          return false;
        }
        if (!.contains(to)) {
          .error("State " + to + " in " + transition
              + " is not a defined state, state model: " + .getId());
          return false;
        }
        // the next state for the transition should be the to state
        if (!to.equals(.getNextStateForTransition(fromto))) {
          .error("Transition " + transition + " must have " + to + " as the next state");
          return false;
        }
      }
    }
    return true;
  }

  
Check if the "next" states in the state model definition are valid. These check the next values at a single level. To check full paths, use arePathsValid().

Returns:
true if next states are properly defined, false otherwise
  private boolean areNextStatesValid() {
    for (String state : ) {
      // all states can reach DROPPED
      if (!state.equals(..toString())
          && .getNextStateForTransition(state..toString()) == null) {
        .error("State " + state + " cannot reach the DROPPED state, state model: "
            + .getId());
        return false;
      }
      // initial state should reach all states (other than error)
      if (!state.equals(.getInitialState())
          && !state.equals(..toString())
          && .getNextStateForTransition(.getInitialState(), state) == null) {
        .error("Initial state " + .getInitialState()
            + " should be able to reach all states, state model: " + .getId());
        return false;
      }
      // validate "next" states
      for (String destState : ) {
        if (state.equals(destState)) {
          continue;
        }
        // the next state should exist
        String intermediate = .getNextStateForTransition(statedestState);
        if (intermediate != null && !.contains(intermediate)) {
          .error("Intermediate state " + intermediate + " for transition " + state + "-"
              + destState + " is not a valid state, state model: " + .getId());
          return false;
        }
        // the next state should not allow a self loop
        if (intermediate != null && intermediate.equals(state)) {
          .error("Intermediate state " + intermediate + " for transition " + state + "-"
              + destState + " should never be the from state, state model: "
              + .getId());
          return false;
        }
      }
    }
    return true;
  }

  
Check that the state model does not have loops or unreachable states and that next states actually help make progress

Returns:
true if the transitions are valid, false otherwise
  private boolean arePathsValid() {
    // create a map for memoized path checking
    Map<StringSet<String>> alreadyChecked = Maps.newHashMap();
    for (String state : ) {
      alreadyChecked.put(statenew HashSet<String>());
    }
    // check all pairs for paths
    for (String from : ) {
      for (String to : ) {
        // ignore self transitions
        if (from.equals(to)) {
          continue;
        }
        // see if a path is claimed to exist
        Set<Stringused = Sets.newHashSet(from);
        String next = .getNextStateForTransition(fromto);
        if (next == null) {
          if (from.equals(.getInitialState())
              && !to.equals(..toString())) {
            .error("Initial state " + from + " cannot reach " + to + ", state model: "
                + .getId());
            return false;
          }
          continue;
        }
        // if a path exists, follow it all the way
        while (!to.equals(next)) {
          // no need to proceed if this path has already been traversed
          if (alreadyChecked.get(next).contains(to)) {
            break;
          }
          if (used.contains(next)) {
            .error("Path from " + from + " to " + to
                + " contains an infinite loop, state model: " + .getId());
            return false;
          }
          alreadyChecked.get(next).add(to);
          used.add(next);
          next = .getNextStateForTransition(nextto);
          if (next == null) {
            .error("Path from " + from + " to " + to + " is incomplete, state model: "
                + .getId());
            return false;
          }
        }
        alreadyChecked.get(from).add(to);
      }
    }
    return true;
  }

  
Validate a StateModelDefinition instance

Parameters:
stateModelDef the state model definition to validate
Returns:
true if the state model definition is valid, false otherwise
  public static boolean isStateModelDefinitionValid(StateModelDefinition stateModelDef) {
    return new StateModelDefinitionValidator(stateModelDef).isStateModelDefinitionValid();
  }
New to GrepCode? Check out our FAQ X