org.apache.solr.handler.tagger.TagLL Maven / Gradle / Ivy

/*
 * This software was produced for the U. S. Government
 * under Contract No. W15P7T-11-C-F600, and is
 * subject to the Rights in Noncommercial Computer Software
 * and Noncommercial Computer Software Documentation
 * Clause 252.227-7014 (JUN 1995)
 *
 * Copyright 2013 The MITRE Corporation. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.solr.handler.tagger;

import java.io.IOException;

import org.apache.lucene.util.BytesRef;

/**
 * This is a Tag -- a startOffset, endOffset and value.
 * 
 * A Tag starts without a value in an
 * "advancing" state.  {@link #advance(org.apache.lucene.util.BytesRef, int)}
 * is called with subsequent words and then eventually it won't advance any
 * more, and value is set (could be null).
 * 
 * A Tag is also a doubly-linked-list (hence the LL in the name). All tags share
 * a reference to the head via a 1-element array, which is potentially modified
 * if any of the linked-list methods are called. Tags in the list should have
 * equal or increasing start offsets.
 */
public class TagLL{

  private final TagLL[] head;//a shared pointer to the head; 1 element
  TagLL prevTag, nextTag; // linked list

  private TermPrefixCursor cursor;

  final int startOffset;//inclusive
  int endOffset;//exclusive
  Object value;//null means unset

  /** optional boolean used by some TagClusterReducer's */
  boolean mark = false;

  TagLL(TagLL[] head, TermPrefixCursor cursor, int startOffset, int endOffset, Object value) {
    this.head = head;
    this.cursor = cursor;
    this.startOffset = startOffset;
    this.endOffset = endOffset;
    this.value = value;
  }

  /**
   * Advances this tag with "word" at offset "offset".  If this tag is not in
   * an advancing state then it does nothing. If it is advancing and prior to
   * advancing further it sees a value, then a non-advancing tag may be inserted
   * into the LL as side-effect. If this returns false (it didn't advance) and
   * if there is no value, then it will also be removed.
   *
   *
   * @param word      The next word or null if at an end
   * @param offset    The last character in word's offset in the underlying
   *                  stream. If word is null then it's meaningless.
   *
   * @return          Whether it advanced or not.
   */
  boolean advance(BytesRef word, int offset) throws IOException {
    if (!isAdvancing())
      return false;

    Object iVal = cursor.getDocIds();

    if (word != null && cursor.advance(word)) {

      if (iVal != null) {
        addBeforeLL(new TagLL(head, null, startOffset, endOffset, iVal));
      }

      assert offset >= endOffset;
      endOffset = offset;
      return true;
    } else {
      this.value = iVal;
      this.cursor = null;
      if (iVal == null)
        removeLL();
      return false;
    }
  }

  /** Removes this tag from the chain, connecting prevTag and nextTag. Does not
   * modify "this" object's pointers, so the caller can refer to nextTag after
   * removing it. */
  public void removeLL() {
    if (head[0] == this)
      head[0] = nextTag;
    if (prevTag != null) {
      prevTag.nextTag = nextTag;
    }
    if (nextTag != null) {
      nextTag.prevTag = prevTag;
    }
  }

  void addBeforeLL(TagLL tag) {
    assert tag.startOffset <= startOffset;
    if (prevTag != null) {
      assert prevTag.startOffset <= tag.startOffset;
      prevTag.nextTag = tag;
      tag.prevTag = prevTag;
    } else {
      assert head[0] == this;
      head[0] = tag;
    }
    prevTag = tag;
    tag.nextTag = this;
  }

  void addAfterLL(TagLL tag) {
    assert tag.startOffset >= startOffset;
    if (nextTag != null) {
      assert nextTag.startOffset >= tag.startOffset;
      nextTag.prevTag = tag;
      tag.nextTag = nextTag;
    }
    nextTag = tag;
    tag.prevTag = this;
  }

  public int charLen() {
    return endOffset - startOffset;
  }

  public TagLL getNextTag() {
    return nextTag;
  }

  public TagLL getPrevTag() {
    return prevTag;
  }

  public int getStartOffset() {
    return startOffset;
  }
  public int getEndOffset() {
    return endOffset;
  }
  public boolean overlaps(TagLL other) {
    //don't use >= or <= because startOffset is inclusive while endOffset is exclusive
    if (startOffset < other.startOffset)
      return endOffset > other.startOffset;
    else
      return startOffset < other.endOffset;
  }

  boolean isAdvancing() {
    return cursor != null;
  }

  @Override
  public String toString() {
    return (prevTag != null ? '*' : '-') + "|" + (nextTag != null ? '*' : '-') +
        " " + startOffset + " to " + endOffset + (isAdvancing() ? '+' : " #" + value);
  }
}