示例#1
0
  public void visit(TernaryNodeVisitor<C> visitor) {

    visitor.visit(this);

    if (this.lessThanNode != null) lessThanNode.visit(visitor);

    if (this.equalsNode != null) equalsNode.visit(visitor);

    if (this.greaterThanNode != null) greaterThanNode.visit(visitor);
  }
示例#2
0
  /**
   * Find all of the matches in the sub trie indicated and add them onto the list.
   *
   * @param wordList
   * @param limit
   * @param first true if we want to only include the equals first
   */
  public void accumulate(List<C> wordList, int limit, boolean first) {

    for (List<C> col : this.valueListMap.values()) {
      wordList.addAll(col);
    }

    if (!first && lessThanNode != null) lessThanNode.accumulate(wordList, limit, false);

    if (equalsNode != null) equalsNode.accumulate(wordList, limit, false);

    if (!first && greaterThanNode != null) greaterThanNode.accumulate(wordList, limit, false);
  }
示例#3
0
  /**
   * @param levelZeroSet
   *     <p>Visit all of the level zero nodes and add their character value into the set.
   */
  public void getStartingCharacterSet(Set<String> levelZeroSet) {

    if (this.level > 0) return;

    if (this.level == 0) {

      levelZeroSet.add(this.character);

      if (lessThanNode != null) lessThanNode.getStartingCharacterSet(levelZeroSet);

      if (greaterThanNode != null) greaterThanNode.getStartingCharacterSet(levelZeroSet);
    }
  }
示例#4
0
  public void collect(List<C> valueList) {
    // private void collect(Node x, String prefix, Queue<String> queue) {
    // if (x == null) return;
    // collect(x.left, prefix, queue);
    // if (x.val != null) queue.enqueue(prefix + x.c);
    // collect(x.mid, prefix + x.c, queue);
    // collect(x.right, prefix, queue);

    for (List<C> col : this.valueListMap.values()) {
      valueList.addAll(col);
    }

    if (lessThanNode != null) lessThanNode.collect(valueList);

    if (equalsNode != null) equalsNode.collect(valueList);

    if (greaterThanNode != null) greaterThanNode.collect(valueList);
  }
示例#5
0
  /**
   * @param prefix
   * @return the node theat matches the prefix given.
   */
  public TernaryNode<C> matchPrefix(String prefix) {

    // private Node get(Node x, String key, int d) {
    // if (key == null || key.length() == 0) throw new RuntimeException("illegal key");
    // if (x == null) return null;
    // char c = key.charAt(d);
    // if (c < x.c) return get(x.left, key, d);
    // else if (c > x.c) return get(x.right, key, d);
    // else if (d < key.length() - 1) return get(x.mid, key, d+1);
    // else return x;

    if (prefix.length() == 0) return this;

    String testCharacter = prefix.substring(this.level, this.level + 1);

    String thisCharacter = this.character;

    int comparison = testCharacter.compareTo(thisCharacter);

    if (comparison < 0) {

      if (lessThanNode != null) return lessThanNode.matchPrefix(prefix);
      else return null;

    } else if (comparison > 0) {

      if (greaterThanNode != null) return greaterThanNode.matchPrefix(prefix);
      else return null;

    } else if (level < prefix.length() - 1) {
      // equals

      if (equalsNode != null) return equalsNode.matchPrefix(prefix);
      else return null;

    } else {
      return this;
    }
  }
示例#6
0
  /**
   * Write the word into the index adding nodes when required.
   *
   * @param word
   * @param value
   */
  public void index(String word, C value) {

    if (isCompressedLeafNode()) {

      // is the word contained within our string.

      // if (this.character.startsWith(word)) {
      //
      // int index = word.length()-1;
      //
      // List<C>matchList = this.valueListMap.get(index);
      //
      // if (matchList == null) {
      // matchList = new LinkedList<C>();
      // this.valueListMap.put(index, matchList);
      // }
      //
      // matchList.add(value);
      // }
      // else {
    }

    String testCharacter = word.substring(this.level, this.level + 1);

    int comparison = testCharacter.compareTo(this.character);

    if (comparison < 0) {

      if (lessThanNode == null) lessThanNode = new TernaryNode<C>(this, this.level, testCharacter);

      lessThanNode.index(word, value);

    } else if (comparison > 0) {

      if (greaterThanNode == null)
        greaterThanNode = new TernaryNode<C>(this, this.level, testCharacter);

      greaterThanNode.index(word, value);

    } else if (level < word.length() - 1) {
      // equals

      if (equalsNode == null) {
        // if null we write the rest of the string into this node
        equalsNode = new TernaryNode<C>(this, this.level + 1, word.substring(this.level + 1));

      } else {
        equalsNode.index(word, value);
      }

    } else {
      // terminates here
      List<C> valueList = this.valueListMap.get(0);

      if (valueList == null) {
        valueList = new LinkedList<C>();
        this.valueListMap.put(0, valueList);
      }

      valueList.add(value);
    }
  }