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

Making http requests using okhttp

A thread is a thread of execution in a program. The Java Virtual Machine allows
an application to ha

java.lang.Thread

A Comparator is used to compare two objects to determine their ordering with
respect to each other. 

java.util.Comparator

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

java.util.Deque

An iterator over a sequence of objects, such as a collection.If a collection has
been changed since 

java.util.Iterator

Defines a general exception a servlet can throw when it encounters difficulty.

javax.servlet.ServletException

Class that models an arbitrary location in a Resource.Typically used to track
the location of proble

org.springframework.beans.factory.parsing.Location

addToBackStack

getContentResolver

notifyDataSetChanged

/** Absolute copy bytes self to self, without changing the
   *  position. Note: this cannot "grow" the bytes, so must
   *  only call it on already written parts. */

//System.out.println("BS.copyBytes src=" + src + " dest=" + dest + " len=" + len);

// Note: weird: must go "backwards" because copyBytes

// calls us with overlapping src/dest.  If we

// go forwards then we overwrite bytes before we can

/*
    int blockIndex = src >> blockBits;
    int upto = src & blockMask;
    byte[] block = blocks.get(blockIndex);
    while (len > 0) {
      int chunk = blockSize - upto;
      System.out.println("  cycle: chunk=" + chunk + " len=" + len);
      if (len <= chunk) {
        writeBytes(dest, block, upto, len);
        break;
      } else {
        writeBytes(dest, block, upto, chunk);
        blockIndex++;
        block = blocks.get(blockIndex);
        upto = 0;
        len -= chunk;
        dest += chunk;
      }
    }
    */

//System.out.println("  cycle downTo=" + downTo);

//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]);

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

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

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