How to use

createTerm

method

in

org.apache.lucene.index.Term

Term term = idTerm.createTerm(idFieldType.toInternal(cmd.id));

  logger.debug("Adding " + shardedId + " to " + indexName);
Term idTerm = this.idTerm.createTerm(cmd.indexedId);

  /**
   * Creates a Term with the given <code>id</code> value and with a field
   * name {@link FieldNames#UUID}.
   *
   * @param id the id.
   * @return the UUIDTerm.
   */
  public static Term createUUIDTerm(String id) {
    return UUID_TERM_TEMPLATE.createTerm(id);
  }
}

  /**
   * Creates a Term with the given <code>id</code> value and with a field
   * name {@link FieldNames#UUID}.
   *
   * @param id the id.
   * @return the UUIDTerm.
   */
  public static Term createUUIDTerm(String id) {
    return UUID_TERM_TEMPLATE.createTerm(id);
  }
}

Term createTerm(String termVal) {
 return fterm.createTerm(termVal);
}

public boolean skipTo(String target) throws IOException {
 return skipTo(tindex.fterm.createTerm(target));
}

public Term term() {
  Term t = super.term();
  if (t == null) {
    return t;
  }
  if (t.field().equals(FieldNames.PROPERTIES)) {
    String text = t.text();
    return t.createTerm(text.replace(oldSepChar, '['));
  } else {
    return t;
  }
}

public Term term() {
  Term t = super.term();
  if (t == null) {
    return t;
  }
  if (t.field().equals(FieldNames.PROPERTIES)) {
    String text = t.text();
    return t.createTerm(text.replace(oldSepChar, '['));
  } else {
    return t;
  }
}

public void seek(Term term) throws IOException {
  if (term.field().equals(FieldNames.PROPERTIES)) {
    char[] text = term.text().toCharArray();
    text[term.text().indexOf('[')] = oldSepChar;
    super.seek(term.createTerm(new String(text)));
  } else {
    super.seek(term);
  }
}

public void seek(Term term) throws IOException {
  if (term.field().equals(FieldNames.PROPERTIES)) {
    char[] text = term.text().toCharArray();
    text[term.text().indexOf('[')] = oldSepChar;
    super.seek(term.createTerm(new String(text)));
  } else {
    super.seek(term);
  }
}

public void seek(Term term) throws IOException
{
 if (term.field().equals(FieldNames.PROPERTIES))
 {
   char[] text = term.text().toCharArray();
   text[term.text().indexOf('[')] = '\uFFFF';
   super.seek(term.createTerm(new String(text)));
 }
 else
 {
   super.seek(term);
 }
}

public String search(String key) {
  String result = null;
  try {
    TermDocs termDocs = indexReader.termDocs(keyTerm.createTerm(key));
    if (termDocs.next()) {
      Document doc = indexReader.document(termDocs.doc());
      result = doc.get(valueFieldName);
    }
  } catch (IOException e) {
    logger.error(e);
  }
  return result;
}

public Term term()
{
 Term t = super.term();
 if (t == null)
 {
   return t;
 }
 if (t.field().equals(FieldNames.PROPERTIES))
 {
   String text = t.text();
   return t.createTerm(text.replace('\uFFFF', '['));
 }
 else
 {
   return t;
 }
}

private int getDocFreq(String term) {
 int result = 1;
 currentTerm = currentTerm.createTerm(term);
 try {
  TermEnum termEnum = reader.terms(currentTerm);
  if (termEnum != null && termEnum.term().equals(currentTerm)) {
   result = termEnum.docFreq();
  }
 } catch (IOException e) {
  throw new RuntimeException(e);
 }
 return result;
}

public String search(String key) {
  String ret = null;
  try {
    TermDocs termDocs = indexReader.termDocs(keyTerm.createTerm(key));
    if (termDocs.next()) {
      Document doc = indexReader.document(termDocs.doc());
      ret = new String(doc.getBinaryValue(valueFieldName));
    }
  } catch (IOException e) {
    logger.error(e);
  }
  return ret;
}

public String search(String page) {
  String pageAbstract = null;
  try {
    TermDocs termDocs = indexReader.termDocs(keyTerm.createTerm(page));
    if (termDocs.next()) {
      Document doc = indexReader.document(termDocs.doc());
      pageAbstract = new String(doc.getBinaryValue("xml"));
    }
  } catch (Exception e) {
    return new String();
  }
  return pageAbstract;
}

/**
 * Check whether the word exists in the index.
 * @param word
 * @throws IOException
 * @throws AlreadyClosedException if the Spellchecker is already closed
 * @return true if the word exists in the index
 */
public boolean exist(String word) throws IOException {
 // obtainSearcher calls ensureOpen
 final IndexSearcher indexSearcher = obtainSearcher();
 try{
  return indexSearcher.docFreq(F_WORD_TERM.createTerm(word)) > 0;
 } finally {
  releaseSearcher(indexSearcher);
 }
}

private NamedList getListedTermCounts(String field, String termList) throws IOException {
 FieldType ft = searcher.getSchema().getFieldType(field);
 List<String> terms = StrUtils.splitSmart(termList, ",", true);
 NamedList res = new NamedList();
 Term t = new Term(field);
 for (String term : terms) {
  String internal = ft.toInternal(term);
  int count = searcher.numDocs(new TermQuery(t.createTerm(internal)), base);
  res.add(term, count);
 }
 return res;    
}

public Integer search(String key) {
  Integer ret = null;
  try {
    TermDocs termDocs = indexReader.termDocs(keyTerm.createTerm(key));
    if (termDocs.next()) {
      Document doc = indexReader.document(termDocs.doc());
      ret = SerialUtils.toInt(doc.getBinaryValue(valueFieldName));
    }
  } catch (IOException e) {
    logger.error(e);
  }
  return ret;
}

  public Term replaceTerm(Term term) throws SearchEngineException {
    try {
      if (spellChecker.exist(term.text())) {
        return term;
      }
      String[] similarWords = spellChecker.suggestSimilar(term.text(), getDefaultNumberOfSuggestions());
      if (similarWords.length == 0) {
        return term;
      }
      suggestedQuery.set(true);
      return term.createTerm(similarWords[0]);
    } catch (IOException e) {
      throw new SearchEngineException("Failed to suggest for query", e);
    }
  }
});