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

BytesStore

Creating JSON documents from java classes using gson

A writable sink for bytes.Most clients will use output streams that write data
to the file system ( 

java.io.OutputStream

Java representation of an SQL TIME value. Provides utilities to format and parse
the time's represen

java.sql.Time

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

java.util.Deque

A task that returns a result and may throw an exception. Implementors define a
single method with no

java.util.concurrent.Callable

Factory for creating Log instances, with discovery and configuration features
similar to that employ

org.apache.commons.logging.LogFactory

Abstract superclass of object loading (and querying) strategies. This class
implements useful common

org.hibernate.loader.Loader

requestLocationUpdates

onRequestPermissionsResult

startActivity

/** 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 writeVIntmethodin org.apache.lucene.util.fst.BytesStore

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

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