Public

<init>

createStartState

createState

getCurrentStateName

getStartTimestamp

getVersion

equals

getPreviousBufferEntry

getStartEventID

getConditionContext

getCounter

getEvent

getPreviousState

getState

getTimestamp

isFinalState

isStartState

isStopState

Charset

Reading from database using SQL prepared statement

A Rectangle specifies an area in a coordinate space that is enclosed by the 
Rectangle object's top-

java.awt.Rectangle

The abstract base class for all number formats. This class provides the
interface for formatting and

java.text.NumberFormat

Note: Do not use this class since it is obsolete. Please use the Map interface
for new implementatio

java.util.Dictionary

A Set is a data structure which does not allow duplicate elements.

java.util.Set

A synchronization aid that allows one or more threads to wait until a set of
operations being perfor

java.util.concurrent.CountDownLatch

A reentrant mutual exclusion Lock with the same basic behavior and semantics as
the implicit monitor

java.util.concurrent.locks.ReentrantLock

getSupportFragmentManager

getResourceAsStream

getExternalFilesDir

/**
	 * Needed for backward compatibility. First migrates the {@link State} graph see {@link NFACompiler#migrateGraph(State)}.
	 * Than recreates the {@link ComputationState}s with the new {@link State} graph.
	 * @param readStates computation states read from snapshot
	 * @return collection of migrated computation states
	 */

/**
	 * Processes the next input event. If some of the computations reach a final state then the
	 * resulting event sequences are returned. If computations time out and timeout handling is
	 * activated, then the timed out event patterns are returned.
	 *
	 * <p>If computations reach a stop state, the path forward is discarded and currently constructed path is returned
	 * with the element that resulted in the stop state.
	 *
	 * @param event The current event to be processed or null if only pruning shall be done
	 * @param timestamp The timestamp of the current event
	 * @return Tuple of the collection of matched patterns (e.g. the result of computations which have
	 * reached a final state) and the collection of timed out patterns (if timeout handling is
	 * activated)
	 */

//delay adding new computation states in case a stop state is reached and we discard the path.

// we've reached a final state and can thus retrieve the matching event sequence

// remove found patterns because they are no longer needed

//reached stop state. release entry for the stop state

// add new computation state; it will be processed once the next event arrives

// a stop state was reached in this branch. release branch which results in removing previous event from

// prune shared buffer based on window length

// the check is to guard against underflows

/**
	 * Computes the next computation states based on the given computation state, the current event,
	 * its timestamp and the internal state machine. The algorithm is:
	 *<ol>
	 *     <li>Decide on valid transitions and number of branching paths. See {@link OutgoingEdges}</li>
	 * 	   <li>Perform transitions:
	 * 	   	<ol>
	 *          <li>IGNORE (links in {@link SharedBuffer} will still point to the previous event)</li>
	 *          <ul>
	 *              <li>do not perform for Start State - special case</li>
	 *          	<li>if stays in the same state increase the current stage for future use with number of outgoing edges</li>
	 *          	<li>if after PROCEED increase current stage and add new stage (as we change the state)</li>
	 *          	<li>lock the entry in {@link SharedBuffer} as it is needed in the created branch</li>
	 *      	</ul>
	 *      	<li>TAKE (links in {@link SharedBuffer} will point to the current event)</li>
	 *          <ul>
	 *              <li>add entry to the shared buffer with version of the current computation state</li>
	 *              <li>add stage and then increase with number of takes for the future computation states</li>
	 *              <li>peek to the next state if it has PROCEED path to a Final State, if true create Final
	 *              ComputationState to emit results</li>
	 *          </ul>
	 *      </ol>
	 *     </li>
	 * 	   <li>Handle the Start State, as it always have to remain </li>
	 *     <li>Release the corresponding entries in {@link SharedBuffer}.</li>
	 *</ol>
	 *
	 * @param computationState Current computation state
	 * @param event Current event which is processed
	 * @param timestamp Timestamp of the current event
	 * @return Collection of computation states which result from the current one
	 */

// Create the computing version based on the previously computed edges

// We need to defer the creation of computation states until we know how many edges start

// at this computation state so that we can assign proper version

//Stay in the same state (it can be either looping one or singleton)

//check if newly created state is optional (have a PROCEED path to Final state)

// release the shared entry referenced by the current computation state.

How to use isStartStatemethodin org.apache.flink.cep.nfa.ComputationState

Best Java code snippets using org.apache.flink.cep.nfa.ComputationState.isStartState (Showing top 3 results out of 315)

How to use
isStartState
method
in
org.apache.flink.cep.nfa.ComputationState