/** * Check if there are duplicate pattern names. If yes, it * throws a {@link MalformedPatternException}. */ private void checkPatternNameUniqueness() { // make sure there is no pattern with name "$endState$" stateNameHandler.checkNameUniqueness(ENDING_STATE_NAME); Pattern patternToCheck = currentPattern; while (patternToCheck != null) { checkPatternNameUniqueness(patternToCheck); patternToCheck = patternToCheck.getPrevious(); } stateNameHandler.clear(); }
public NodeId getNodeId(String prevState, long timestamp, int counter, V event) { return mappingContext.get(Tuple2.of(NFAStateNameHandler.getOriginalNameFromInternal(prevState), new ValueTimeWrapper<>(event, timestamp, counter))); }
/** * Creates a state with {@link State.StateType#Normal} and adds it to the collection of created states. * Should be used instead of instantiating with new operator. * * @return the created state */ private State<T> createState(String name, State.StateType stateType) { String stateName = stateNameHandler.getUniqueInternalName(name); State<T> state = new State<>(stateName, stateType); states.add(state); return state; }
/** * Check if the given pattern's name is already used or not. If yes, it * throws a {@link MalformedPatternException}. * * @param pattern The pattern to be checked */ private void checkPatternNameUniqueness(final Pattern pattern) { if (pattern instanceof GroupPattern) { Pattern patternToCheck = ((GroupPattern) pattern).getRawPattern(); while (patternToCheck != null) { checkPatternNameUniqueness(patternToCheck); patternToCheck = patternToCheck.getPrevious(); } } else { stateNameHandler.checkNameUniqueness(pattern.getName()); } }
/** * Creates the Start {@link State} of the resulting NFA graph. * * @param sinkState the state that Start state should point to (always first state of middle states) * @return created state */ @SuppressWarnings("unchecked") private State<T> createStartState(State<T> sinkState) { stateNameHandler.checkNameUniqueness(currentPattern.getName()); final State<T> beginningState = convertPattern(sinkState); beginningState.makeStart(); return beginningState; }
/** * Stores given value (value + timestamp) under the given state. It assigns a preceding element * relation to the previous entry. * * @param stateName name of the state that the event should be assigned to * @param eventId unique id of event assigned by this SharedBuffer * @param previousNodeId id of previous entry (might be null if start of new run) * @param version Version of the previous relation * @return assigned id of this element */ public NodeId put( final String stateName, final EventId eventId, @Nullable final NodeId previousNodeId, final DeweyNumber version) { if (previousNodeId != null) { lockNode(previousNodeId); } NodeId currentNodeId = new NodeId(eventId, getOriginalNameFromInternal(stateName)); Lockable<SharedBufferNode> currentNode = sharedBuffer.getEntry(currentNodeId); if (currentNode == null) { currentNode = new Lockable<>(new SharedBufferNode(), 0); lockEvent(eventId); } currentNode.getElement().addEdge(new SharedBufferEdge( previousNodeId, version)); sharedBuffer.upsertEntry(currentNodeId, currentNode); return currentNodeId; }
/** * Check if there are duplicate pattern names. If yes, it * throws a {@link MalformedPatternException}. */ private void checkPatternNameUniqueness() { // make sure there is no pattern with name "$endState$" stateNameHandler.checkNameUniqueness(ENDING_STATE_NAME); Pattern patternToCheck = currentPattern; while (patternToCheck != null) { checkPatternNameUniqueness(patternToCheck); patternToCheck = patternToCheck.getPrevious(); } stateNameHandler.clear(); }
/** * Check if the given pattern's name is already used or not. If yes, it * throws a {@link MalformedPatternException}. * * @param pattern The pattern to be checked */ private void checkPatternNameUniqueness(final Pattern pattern) { if (pattern instanceof GroupPattern) { Pattern patternToCheck = ((GroupPattern) pattern).getRawPattern(); while (patternToCheck != null) { checkPatternNameUniqueness(patternToCheck); patternToCheck = patternToCheck.getPrevious(); } } else { stateNameHandler.checkNameUniqueness(pattern.getName()); } }
/** * Creates a state with {@link State.StateType#Normal} and adds it to the collection of created states. * Should be used instead of instantiating with new operator. * * @return the created state */ private State<T> createState(String name, State.StateType stateType) { String stateName = stateNameHandler.getUniqueInternalName(name); State<T> state = new State<>(stateName, stateType); states.add(state); return state; }
private State<T> copy(final State<T> state) { final State<T> copyOfState = createState( NFAStateNameHandler.getOriginalNameFromInternal(state.getName()), state.getStateType()); for (StateTransition<T> tStateTransition : state.getStateTransitions()) { copyOfState.addStateTransition( tStateTransition.getAction(), tStateTransition.getTargetState().equals(tStateTransition.getSourceState()) ? copyOfState : tStateTransition.getTargetState(), tStateTransition.getCondition()); } return copyOfState; }
/** * Check if there are duplicate pattern names. If yes, it * throws a {@link MalformedPatternException}. */ private void checkPatternNameUniqueness() { // make sure there is no pattern with name "$endState$" stateNameHandler.checkNameUniqueness(ENDING_STATE_NAME); Pattern patternToCheck = currentPattern; while (patternToCheck != null) { checkPatternNameUniqueness(patternToCheck); patternToCheck = patternToCheck.getPrevious(); } stateNameHandler.clear(); }
/** * Check if the given pattern's name is already used or not. If yes, it * throws a {@link MalformedPatternException}. * * @param pattern The pattern to be checked */ private void checkPatternNameUniqueness(final Pattern pattern) { if (pattern instanceof GroupPattern) { Pattern patternToCheck = ((GroupPattern) pattern).getRawPattern(); while (patternToCheck != null) { checkPatternNameUniqueness(patternToCheck); patternToCheck = patternToCheck.getPrevious(); } } else { stateNameHandler.checkNameUniqueness(pattern.getName()); } }
/** * Creates a state with {@link State.StateType#Normal} and adds it to the collection of created states. * Should be used instead of instantiating with new operator. * * @return the created state */ private State<T> createState(String name, State.StateType stateType) { String stateName = stateNameHandler.getUniqueInternalName(name); State<T> state = new State<>(stateName, stateType); states.add(state); return state; }
public NodeId getNodeId(String prevState, long timestamp, int counter, V event) { return mappingContext.get(Tuple2.of(NFAStateNameHandler.getOriginalNameFromInternal(prevState), new ValueTimeWrapper<>(event, timestamp, counter))); }
stateNameHandler.checkNameUniqueness(currentPattern.getName()); lastSink = notNext; } else { stateNameHandler.checkNameUniqueness(currentPattern.getName()); lastSink = convertPattern(lastSink);
/** * Creates a state with {@link State.StateType#Normal} and adds it to the collection of created states. * Should be used instead of instantiating with new operator. * * @return the created state */ private State<T> createState(String name, State.StateType stateType) { String stateName = stateNameHandler.getUniqueInternalName(name); State<T> state = new State<>(stateName, stateType); states.add(state); return state; }
public NodeId getNodeId(String prevState, long timestamp, int counter, V event) { return mappingContext.get(Tuple2.of(NFAStateNameHandler.getOriginalNameFromInternal(prevState), new ValueTimeWrapper<>(event, timestamp, counter))); }
private void addComputationState( List<ComputationState<T>> computationStates, State<T> currentState, State<T> previousState, T event, int counter, long timestamp, DeweyNumber version, long startTimestamp) { ComputationState<T> computationState = ComputationState.createState( this, currentState, previousState, event, counter, timestamp, version, startTimestamp); computationStates.add(computationState); String originalStateName = NFAStateNameHandler.getOriginalNameFromInternal(previousState.getName()); eventSharedBuffer.lock(originalStateName, event, timestamp, counter); }
NFAStateNameHandler.getOriginalNameFromInternal( computationState.getPreviousState().getName()), computationState.getEvent(),
NFAStateNameHandler.getOriginalNameFromInternal(computationState.getPreviousState().getName()), computationState.getEvent(), computationState.getTimestamp(), NFAStateNameHandler.getOriginalNameFromInternal( newComputationState.getPreviousState().getName()), newComputationState.getEvent(), NFAStateNameHandler.getOriginalNameFromInternal( newComputationState.getPreviousState().getName()), newComputationState.getEvent(), NFAStateNameHandler.getOriginalNameFromInternal( state.getPreviousState().getName()), state.getEvent(),