Public

<init>

addArc

clear

deleteLast

getLastOutput

prependOutput

replaceLast

setLastOutput

Builder$UnCompiledNode

Parsing JSON documents to java classes using gson

A collection that associates an ordered pair of keys, called a row key and a
column key, with a sing

com.google.common.collect.Table

An abstraction for a native pointer data type. A Pointer instance represents, on
the Java side, a na

com.sun.jna.Pointer

Wraps an existing Reader and buffers the input. Expensive interaction with the
underlying reader is 

java.io.BufferedReader

A concrete subclass of NumberFormat that formats decimal numbers. It has a
variety of features desig

java.text.DecimalFormat

A linear collection that supports element insertion and removal at both ends.
The name deque is shor

java.util.Deque

javax.management.Notification

setScale

findViewById

scheduleAtFixedRate

/** Add the next input/output pair.  The provided input
   *  must be sorted after the previous one according to
   *  {@link IntsRef#compareTo}.  It's also OK to add the same
   *  input twice in a row with different outputs, as long
   *  as {@link Outputs} implements the {@link Outputs#merge}
   *  method. Note that input is fully consumed after this
   *  method is returned (so caller is free to reuse), but
   *  output is not.  So if your outputs are changeable (eg
   *  {@link ByteSequenceOutputs} or {@link
   *  IntSequenceOutputs}) then you cannot reuse across
   *  calls. */

/*
    if (DEBUG) {
      BytesRef b = new BytesRef(input.length);
      for(int x=0;x<input.length;x++) {
        b.bytes[x] = (byte) input.ints[x];
      }
      b.length = input.length;
      if (output == NO_OUTPUT) {
        System.out.println("\nFST ADD: input=" + toString(b) + " " + b);
      } else {
        System.out.println("\nFST ADD: input=" + toString(b) + " " + b + " output=" + fst.outputs.outputToString(output));
      }
    }
    */

// De-dup NO_OUTPUT since it must be a singleton:

"inputs are added out of order lastInput="

// empty input: only allowed as first input.  we have

// to special case this because the packed FST

// format cannot represent the empty input since

// 'finalness' is stored on the incoming arc, not on

//System.out.println("  incr " + pos1 + " ct=" + frontier[pos1].inputCount + " n=" + frontier[pos1]);

// minimize/compile states from previous input's

// push conflicting outputs forward, only as far as

// same input more than 1 time in a row, mapping to

// this new arc is private to this new input; set its

//System.out.println("  count[0]=" + frontier[0].inputCount);

//System.out.println("  compileTail " + prefixLenPlus1);

// prune if parent's inputCount is less than suffixMinCount2

// my parent, about to be compiled, doesn't make the cut, so

// if minSuffixCount2 is 1, we keep only up

// until the 'distinguished edge', ie we keep only the

// 'divergent' part of the FST. if my parent, about to be

// compiled, has inputCount 1 then we are already past the

// distinguished edge.  NOTE: this only works if

// the FST outputs are not "compressible" (simple

// my parent, about to be compiled, does make the cut, so

// if pruning is disabled (count is 0) we can always

//System.out.println("    label=" + ((char) lastInput.ints[lastInput.offset+idx-1]) + " idx=" + idx + " inputCount=" + frontier[idx].inputCount + " doCompile=" + doCompile + " doPrune=" + doPrune);

// We "fake" the node as being final if it has no

// outgoing arcs; in theory we could leave it

// as non-final (the FST can represent this), but

// FSTEnum, Util, etc., have trouble w/ non-final

// this node makes it and we now compile it.  first,

// compile any targets that were previously

// this node will stay in play for now, since we are

// undecided on whether to prune it.  later, it

// will be either compiled or pruned, so we must

/**
   * Instantiates an FST/FSA builder with all the possible tuning and construction
   * tweaks. Read parameter documentation carefully.
   * 
   * @param inputType 
   *    The input type (transition labels). Can be anything from {@link INPUT_TYPE}
   *    enumeration. Shorter types will consume less memory. Strings (character sequences) are 
   *    represented as {@link INPUT_TYPE#BYTE4} (full unicode codepoints). 
   *     
   * @param minSuffixCount1
   *    If pruning the input graph during construction, this threshold is used for telling
   *    if a node is kept or pruned. If transition_count(node) &gt;= minSuffixCount1, the node
   *    is kept. 
   *    
   * @param minSuffixCount2
   *    (Note: only Mike McCandless knows what this one is really doing...) 
   * 
   * @param doShareSuffix 
   *    If <code>true</code>, the shared suffixes will be compacted into unique paths.
   *    This requires an additional RAM-intensive hash map for lookups in memory. Setting this parameter to
   *    <code>false</code> creates a single suffix path for all input sequences. This will result in a larger
   *    FST, but requires substantially less memory and CPU during building.  
   *
   * @param doShareNonSingletonNodes
   *    Only used if doShareSuffix is true.  Set this to
   *    true to ensure FST is fully minimal, at cost of more
   *    CPU and more RAM during building.
   *
   * @param shareMaxTailLength
   *    Only used if doShareSuffix is true.  Set this to
   *    Integer.MAX_VALUE to ensure FST is fully minimal, at cost of more
   *    CPU and more RAM during building.
   *
   * @param outputs The output type for each input sequence. Applies only if building an FST. For
   *    FSA, use {@link NoOutputs#getSingleton()} and {@link NoOutputs#getNoOutput()} as the
   *    singleton output object.
   *
   * @param doPackFST Pass true to create a packed FST.
   * 
   * @param acceptableOverheadRatio How to trade speed for space when building the FST. This option
   *    is only relevant when doPackFST is true. @see PackedInts#getMutable(int, int, float)
   *
   * @param allowArrayArcs Pass false to disable the array arc optimization
   *    while building the FST; this will make the resulting
   *    FST smaller but slower to traverse.
   *
   * @param bytesPageBits How many bits wide to make each
   *    byte[] block in the BytesStore; if you know the FST
   *    will be large then make this larger.  For example 15
   *    bits = 32768 byte pages.
   */

/**
   * Instantiates an FST/FSA builder with all the possible tuning and construction
   * tweaks. Read parameter documentation carefully.
   * 
   * @param inputType 
   *    The input type (transition labels). Can be anything from {@link INPUT_TYPE}
   *    enumeration. Shorter types will consume less memory. Strings (character sequences) are 
   *    represented as {@link INPUT_TYPE#BYTE4} (full unicode codepoints). 
   *     
   * @param minSuffixCount1
   *    If pruning the input graph during construction, this threshold is used for telling
   *    if a node is kept or pruned. If transition_count(node) &gt;= minSuffixCount1, the node
   *    is kept. 
   *    
   * @param minSuffixCount2
   *    (Note: only Mike McCandless knows what this one is really doing...) 
   * 
   * @param doShareSuffix 
   *    If <code>true</code>, the shared suffixes will be compacted into unique paths.
   *    This requires an additional RAM-intensive hash map for lookups in memory. Setting this parameter to
   *    <code>false</code> creates a single suffix path for all input sequences. This will result in a larger
   *    FST, but requires substantially less memory and CPU during building.  
   *
   * @param doShareNonSingletonNodes
   *    Only used if doShareSuffix is true.  Set this to
   *    true to ensure FST is fully minimal, at cost of more
   *    CPU and more RAM during building.
   *
   * @param shareMaxTailLength
   *    Only used if doShareSuffix is true.  Set this to
   *    Integer.MAX_VALUE to ensure FST is fully minimal, at cost of more
   *    CPU and more RAM during building.
   *
   * @param outputs The output type for each input sequence. Applies only if building an FST. For
   *    FSA, use {@link NoOutputs#getSingleton()} and {@link NoOutputs#getNoOutput()} as the
   *    singleton output object.
   *
   * @param allowArrayArcs Pass false to disable the array arc optimization
   *    while building the FST; this will make the resulting
   *    FST smaller but slower to traverse.
   *
   * @param bytesPageBits How many bits wide to make each
   *    byte[] block in the BytesStore; if you know the FST
   *    will be large then make this larger.  For example 15
   *    bits = 32768 byte pages.
   */

How to use org.apache.lucene.util.fst.Builder$UnCompiledNodeconstructor

Best Java code snippets using org.apache.lucene.util.fst.Builder$UnCompiledNode.<init> (Showing top 12 results out of 315)

How to use
org.apache.lucene.util.fst.Builder$UnCompiledNode
constructor