Public

Pulls bytes from the provided IndexInput.

<init>

copyBytes

finish

getPosition

getReverseReader

ramBytesUsed

Reverse from srcPos, inclusive, to destPos, inclusive.

reverse

skipBytes

Absolute write byte; you must ensure dest is < max position written so far.

writeByte

writeBytes

Writes all of our bytes to the target DataOutput.

writeTo

writeVLong

getBlockBits

getForwardReader

Pos must be less than the max position written so far! Ie, you cannot "grow" the
file with this!

truncate

writeVInt

Updating database using SQL prepared statement

Thrown when a file specified by a program cannot be found.

java.io.FileNotFoundException

A connection to a URL for reading or writing. For HTTP connections, see
HttpURLConnection for docume

java.net.URLConnection

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

java.util.Dictionary

A counting semaphore. Conceptually, a semaphore maintains a set of permits. Each
#acquire blocks if 

java.util.concurrent.Semaphore

The Modifier class provides static methods and constants to decode class and
member access modifiers

javassist.Modifier

General IO stream manipulation utilities. This class provides static utility
methods for input/outpu

org.apache.commons.io.IOUtils

findViewById

scheduleAtFixedRate

setRequestProperty

//System.out.println("FST.addNode pos=" + bytes.getPosition() + " numArcs=" + nodeIn.numArcs);

//System.out.println("  startAddr=" + startAddress);

//System.out.println("  arc " + arcIdx + " label=" + arc.label + " -> target=" + target.node);

// TODO: for better perf (but more RAM used) we

// could avoid this except when arc is "near" the

// System.out.println("  write arc: label=" + (char) arc.label + " flags=" + flags + " target=" + target.node + " pos=" + bytes.getPosition() + " output=" + outputs.outputToString(arc.output));

//System.out.println("    write output");

//System.out.println("    write final output");

//System.out.println("    write target");

// just write the arcs "like normal" on first pass,

// but record how many bytes each one took, and max

//System.out.println("    bytes=" + builder.reusedBytesPerArc[arcIdx]);

// TODO: try to avoid wasteful cases: disable doFixedArray in that case

/* 
     * 
     * LUCENE-4682: what is a fair heuristic here?
     * It could involve some of these:
     * 1. how "busy" the node is: nodeIn.inputCount relative to frontier[0].inputCount?
     * 2. how much binSearch saves over scan: nodeIn.numArcs
     * 3. waste: numBytes vs numBytesExpanded
     * 
     * the one below just looks at #3
    if (doFixedArray) {
      // rough heuristic: make this 1.25 "waste factor" a parameter to the phd ctor????
      int numBytes = lastArcStart - startAddress;
      int numBytesExpanded = maxBytesPerArc * nodeIn.numArcs;
      if (numBytesExpanded > numBytes*1.25) {
        doFixedArray = false;
      }
    }
    */

// header(byte) + numArcs(vint) + numBytes(vint)

// 2nd pass just "expands" all arcs to take up a fixed

//System.out.println("write int @pos=" + (fixedArrayStart-4) + " numArcs=" + nodeIn.numArcs);

// TODO: clean this up: or just rewind+reuse and deal with it

//System.out.println("  repack arcIdx=" + arcIdx + " srcPos=" + srcPos + " destPos=" + destPos);

//System.out.println("  copy len=" + builder.reusedBytesPerArc[arcIdx]);

/** Expert: creates an FST by packing this one.  This
   *  process requires substantial additional RAM (currently
   *  up to ~8 bytes per node depending on
   *  <code>acceptableOverheadRatio</code>), but then should
   *  produce a smaller FST.
   *
   *  <p>The implementation of this method uses ideas from
   *  <a target="_blank" href="http://www.cs.put.poznan.pl/dweiss/site/publications/download/fsacomp.pdf">Smaller Representation of Finite State Automata</a>,
   *  which describes techniques to reduce the size of a FST.
   *  However, this is not a strict implementation of the
   *  algorithms described in this paper.
   */

// NOTE: maxDerefNodes is intentionally int: we cannot

//   - renumber the nodes to get more next / better locality?

//   - allow multiple input labels on an arc, so

//     singular chain of inputs can take one arc (on

//     wikipedia terms this could save another ~6%)

//   - in the ord case, the output '1' is presumably

//     very common (after NO_OUTPUT)... maybe use a bit

//   - use spare bits in flags.... for top few labels /

"this FST was not built with willPackFST=true"

// Find top nodes with highest number of incoming arcs:

// TODO: we could use more RAM efficient selection algo here...

//System.out.println("map node=" + n.node + " inCount=" + n.count + " to newID=" + downTo);

// +1 because node ords start at 1 (0 is reserved as stop node):

// Skip 0 byte since 0 is reserved target:

// Since we re-reverse the bytes, we now write the

// nodes backwards, so that BIT_TARGET_NEXT is

//System.out.println("  node: " + node + " address=" + address);

//System.out.println("    change: " + (address - newNodeAddress[node]));

How to use skipBytesmethodin org.apache.lucene.util.fst.BytesStore

Best Java code snippets using org.apache.lucene.util.fst.BytesStore.skipBytes (Showing top 6 results out of 315)

How to use
skipBytes
method
in
org.apache.lucene.util.fst.BytesStore