org.apache.lucene.util.fst.Builder$UnCompiledNode java code examples

Common ways to obtain Builder$UnCompiledNode

private void myMethod () {
 Builder$UnCompiledNode b =new UnCompiledNode<>(this, depth)
Smart code suggestions by Tabnine
}

final UnCompiledNode<T>[] next = ArrayUtil.grow(frontier, input.length+1);
for(int idx=frontier.length;idx<next.length;idx++) {
 next[idx] = new UnCompiledNode<>(this, idx);
frontier[idx-1].addArc(input.ints[input.offset + idx - 1],
            frontier[idx]);
frontier[idx].inputCount++;
final UnCompiledNode<T> parentNode = frontier[idx-1];
final T lastOutput = parentNode.getLastOutput(input.ints[input.offset + idx - 1]);
assert validOutput(lastOutput);
 wordSuffix = fst.outputs.subtract(lastOutput, commonOutputPrefix);
 assert validOutput(wordSuffix);
 parentNode.setLastOutput(input.ints[input.offset + idx - 1], commonOutputPrefix);
 node.prependOutput(wordSuffix);
} else {
 commonOutputPrefix = wordSuffix = NO_OUTPUT;
frontier[prefixLenPlus1-1].setLastOutput(input.ints[input.offset + prefixLenPlus1-1], output);

  @SuppressWarnings({"rawtypes","unchecked"}) final UnCompiledNode<T> target =
  (UnCompiledNode<T>) node.arcs[arcIdx].target;
  target.clear();
 node.clear();
 parent.deleteLast(lastInput.intAt(idx-1), node);
} else {
  parent.replaceLast(lastInput.intAt(idx-1),
            compileNode(node, 1+lastInput.length()-idx),
            nextFinalOutput,
  parent.replaceLast(lastInput.intAt(idx-1),
            node,
            nextFinalOutput,
  frontier[idx] = new UnCompiledNode<>(this, idx);

System.arraycopy(frontier, 0, next, 0, frontier.length);
for(int idx=frontier.length;idx<next.length;idx++) {
 next[idx] = new UnCompiledNode<>(this, idx);
frontier[idx-1].addArc(input.ints[input.offset + idx - 1],
            frontier[idx]);
frontier[idx].inputCount++;
final UnCompiledNode<T> parentNode = frontier[idx-1];
final T lastOutput = parentNode.getLastOutput(input.ints[input.offset + idx - 1]);
assert validOutput(lastOutput);
 wordSuffix = fst.outputs.subtract(lastOutput, commonOutputPrefix);
 assert validOutput(wordSuffix);
 parentNode.setLastOutput(input.ints[input.offset + idx - 1], commonOutputPrefix);
 node.prependOutput(wordSuffix);
} else {
 commonOutputPrefix = wordSuffix = NO_OUTPUT;
frontier[prefixLenPlus1-1].setLastOutput(input.ints[input.offset + prefixLenPlus1-1], output);

frontier = f;
for(int idx=0;idx<frontier.length;idx++) {
 frontier[idx] = new UnCompiledNode<>(this, idx);

  @SuppressWarnings({"rawtypes","unchecked"}) final UnCompiledNode<T> target =
  (UnCompiledNode<T>) node.arcs[arcIdx].target;
  target.clear();
 node.clear();
 parent.deleteLast(lastInput.intAt(idx-1), node);
} else {
  parent.replaceLast(lastInput.intAt(idx-1),
            compileNode(node, 1+lastInput.length()-idx),
            nextFinalOutput,
  parent.replaceLast(lastInput.intAt(idx-1),
            node,
            nextFinalOutput,
  frontier[idx] = new UnCompiledNode<>(this, idx);

System.arraycopy(frontier, 0, next, 0, frontier.length);
for(int idx=frontier.length;idx<next.length;idx++) {
 next[idx] = new UnCompiledNode<>(this, idx);
frontier[idx-1].addArc(input.ints[input.offset + idx - 1],
            frontier[idx]);
frontier[idx].inputCount++;
final UnCompiledNode<T> parentNode = frontier[idx-1];
final T lastOutput = parentNode.getLastOutput(input.ints[input.offset + idx - 1]);
assert validOutput(lastOutput);
 wordSuffix = fst.outputs.subtract(lastOutput, commonOutputPrefix);
 assert validOutput(wordSuffix);
 parentNode.setLastOutput(input.ints[input.offset + idx - 1], commonOutputPrefix);
 node.prependOutput(wordSuffix);
} else {
 commonOutputPrefix = wordSuffix = NO_OUTPUT;
frontier[prefixLenPlus1-1].setLastOutput(input.ints[input.offset + prefixLenPlus1-1], output);

final UnCompiledNode<T>[] next = ArrayUtil.grow(frontier, input.length+1);
for(int idx=frontier.length;idx<next.length;idx++) {
 next[idx] = new UnCompiledNode<>(this, idx);
frontier[idx-1].addArc(input.ints[input.offset + idx - 1],
            frontier[idx]);
frontier[idx].inputCount++;
final UnCompiledNode<T> parentNode = frontier[idx-1];
final T lastOutput = parentNode.getLastOutput(input.ints[input.offset + idx - 1]);
assert validOutput(lastOutput);
 wordSuffix = fst.outputs.subtract(lastOutput, commonOutputPrefix);
 assert validOutput(wordSuffix);
 parentNode.setLastOutput(input.ints[input.offset + idx - 1], commonOutputPrefix);
 node.prependOutput(wordSuffix);
} else {
 commonOutputPrefix = wordSuffix = NO_OUTPUT;
frontier[prefixLenPlus1-1].setLastOutput(input.ints[input.offset + prefixLenPlus1-1], output);

frontier = f;
for(int idx=0;idx<frontier.length;idx++) {
 frontier[idx] = new UnCompiledNode<>(this, idx);

  @SuppressWarnings({"rawtypes","unchecked"}) final UnCompiledNode<T> target =
  (UnCompiledNode<T>) node.arcs[arcIdx].target;
  target.clear();
 node.clear();
 parent.deleteLast(lastInput.intAt(idx-1), node);
} else {
  parent.replaceLast(lastInput.intAt(idx-1),
            compileNode(node, 1+lastInput.length()-idx),
            nextFinalOutput,
  parent.replaceLast(lastInput.intAt(idx-1),
            node,
            nextFinalOutput,
  frontier[idx] = new UnCompiledNode<>(this, idx);

  @SuppressWarnings({"rawtypes","unchecked"}) final UnCompiledNode<T> target =
  (UnCompiledNode<T>) node.arcs[arcIdx].target;
  target.clear();
 node.clear();
 parent.deleteLast(lastInput.intAt(idx-1), node);
} else {
  parent.replaceLast(lastInput.intAt(idx-1),
            compileNode(node, 1+lastInput.length()-idx),
            nextFinalOutput,
  parent.replaceLast(lastInput.intAt(idx-1),
            node,
            nextFinalOutput,
  frontier[idx] = new UnCompiledNode<>(this, idx);

frontier = f;
for(int idx=0;idx<frontier.length;idx++) {
 frontier[idx] = new UnCompiledNode<>(this, idx);

private CompiledNode compileNode(UnCompiledNode<T> nodeIn, int tailLength) throws IOException {
 final long node;
 long bytesPosStart = bytes.getPosition();
 if (dedupHash != null && (doShareNonSingletonNodes || nodeIn.numArcs <= 1) && tailLength <= shareMaxTailLength) {
  if (nodeIn.numArcs == 0) {
   node = fst.addNode(this, nodeIn);
   lastFrozenNode = node;
  } else {
   node = dedupHash.add(this, nodeIn);
  }
 } else {
  node = fst.addNode(this, nodeIn);
 }
 assert node != -2;
 long bytesPosEnd = bytes.getPosition();
 if (bytesPosEnd != bytesPosStart) {
  // The FST added a new node:
  assert bytesPosEnd > bytesPosStart;
  lastFrozenNode = node;
 }
 nodeIn.clear();
 final CompiledNode fn = new CompiledNode();
 fn.node = node;
 return fn;
}

private CompiledNode compileNode(UnCompiledNode<T> nodeIn, int tailLength) throws IOException {
 final long node;
 long bytesPosStart = bytes.getPosition();
 if (dedupHash != null && (doShareNonSingletonNodes || nodeIn.numArcs <= 1) && tailLength <= shareMaxTailLength) {
  if (nodeIn.numArcs == 0) {
   node = fst.addNode(this, nodeIn);
   lastFrozenNode = node;
  } else {
   node = dedupHash.add(this, nodeIn);
  }
 } else {
  node = fst.addNode(this, nodeIn);
 }
 assert node != -2;
 long bytesPosEnd = bytes.getPosition();
 if (bytesPosEnd != bytesPosStart) {
  // The FST added a new node:
  assert bytesPosEnd > bytesPosStart;
  lastFrozenNode = node;
 }
 nodeIn.clear();
 final CompiledNode fn = new CompiledNode();
 fn.node = node;
 return fn;
}

private CompiledNode compileNode(UnCompiledNode<T> nodeIn, int tailLength) throws IOException {
 final long node;
 long bytesPosStart = bytes.getPosition();
 if (dedupHash != null && (doShareNonSingletonNodes || nodeIn.numArcs <= 1) && tailLength <= shareMaxTailLength) {
  if (nodeIn.numArcs == 0) {
   node = fst.addNode(this, nodeIn);
   lastFrozenNode = node;
  } else {
   node = dedupHash.add(this, nodeIn);
  }
 } else {
  node = fst.addNode(this, nodeIn);
 }
 assert node != -2;
 long bytesPosEnd = bytes.getPosition();
 if (bytesPosEnd != bytesPosStart) {
  // The FST added a new node:
  assert bytesPosEnd > bytesPosStart;
  lastFrozenNode = node;
 }
 nodeIn.clear();
 final CompiledNode fn = new CompiledNode();
 fn.node = node;
 return fn;
}

frontier = f;
for(int idx=0;idx<frontier.length;idx++) {
 frontier[idx] = new UnCompiledNode<>(this, idx);

private CompiledNode compileNode(UnCompiledNode<T> nodeIn, int tailLength) throws IOException {
 final long node;
 long bytesPosStart = bytes.getPosition();
 if (dedupHash != null && (doShareNonSingletonNodes || nodeIn.numArcs <= 1) && tailLength <= shareMaxTailLength) {
  if (nodeIn.numArcs == 0) {
   node = fst.addNode(this, nodeIn);
   lastFrozenNode = node;
  } else {
   node = dedupHash.add(this, nodeIn);
  }
 } else {
  node = fst.addNode(this, nodeIn);
 }
 assert node != -2;
 long bytesPosEnd = bytes.getPosition();
 if (bytesPosEnd != bytesPosStart) {
  // The FST added a new node:
  assert bytesPosEnd > bytesPosStart;
  lastFrozenNode = node;
 }
 nodeIn.clear();
 final CompiledNode fn = new CompiledNode();
 fn.node = node;
 return fn;
}

Javadoc

Expert: holds a pending (seen but not yet serialized) Node.

Most used methods

Popular in Java

Reading from database using SQL prepared statement
getSystemService (Context)
getResourceAsStream (ClassLoader)
scheduleAtFixedRate (ScheduledExecutorService)
Time (java.sql)
Java representation of an SQL TIME value. Provides utilities to format and parse the time's represen
Comparator (java.util)
A Comparator is used to compare two objects to determine their ordering with respect to each other.
Modifier (javassist)
The Modifier class provides static methods and constants to decode class and member access modifiers
Notification (javax.management)
Response (javax.ws.rs.core)
Defines the contract between a returned instance and the runtime when an application needs to provid
Get (org.apache.hadoop.hbase.client)
Used to perform Get operations on a single row. To get everything for a row, instantiate a Get objec
Top 25 Plugins for Webstorm

How to useBuilder$UnCompiledNode in org.apache.lucene.util.fst

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

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