How to use

stringValue

method

in

org.apache.lucene.index.IndexableField

private Object getFieldValue( IndexableField field )
{
  Number numericFieldValue = field.numericValue();
  return numericFieldValue != null ? numericFieldValue : field.stringValue();
}

/** Returns the string value of the field with the given name if any exist in
 * this document, or null.  If multiple fields exist with this name, this
 * method returns the first value added. If only binary fields with this name
 * exist, returns null.
 * For a numeric {@link StoredField} it returns the string value of the number. If you want
 * the actual numeric field instance back, use {@link #getField}.
 */
public final String get(String name) {
 for (IndexableField field : fields) {
  if (field.name().equals(name) && field.stringValue() != null) {
   return field.stringValue();
  }
 }
 return null;
}

/**
 * Extract the Apache Geode key term from a lucene document
 */
public static Term getKeyTerm(Document doc) {
 IndexableField field = doc.getField(KEY_FIELD);
 if (field.stringValue() != null) {
  return new Term(KEY_FIELD, field.stringValue());
 } else {
  return new Term(KEY_FIELD, field.binaryValue());
 }
}

/**
 * Extract the Apache Geode key from a lucene document
 */
public static Object getKey(Document doc) {
 IndexableField field = doc.getField(KEY_FIELD);
 if (field.stringValue() != null) {
  return field.stringValue();
 } else {
  return keyFromBytes(field.binaryValue());
 }
}

 private Collection<Object> getResultCollection(IndexableField[] fieldsInDoc, boolean isNumeric) {
  Collection<Object> results = new LinkedHashSet();
  for (IndexableField field : fieldsInDoc) {
   if (isNumeric) {
    results.add((Object) field.numericValue());
   } else {
    results.add(field.stringValue());
   }
  }
  return results;
 }
}

 private Collection<Object> getResultCollection(IndexableField[] fieldsInDoc, boolean isNumeric) {
  Collection<Object> results = new LinkedHashSet();
  for (IndexableField field : fieldsInDoc) {
   if (isNumeric) {
    results.add((Object) field.numericValue());
   } else {
    results.add(field.stringValue());
   }
  }
  return results;
 }
}

private void removeFromCache( long entityId ) throws IOException
{
  IndexSearcher searcher = searcherManager.acquire();
  try
  {
    Query query = type.idTermQuery( entityId );
    TopDocs docs = searcher.search( query, 1 );
    if ( docs.totalHits > 0 )
    {
      Document document = searcher.doc( docs.scoreDocs[0].doc );
      for ( IndexableField field : document.getFields() )
      {
        String key = field.name();
        Object value = field.stringValue();
        removeFromCache( entityId, key, value );
      }
    }
  }
  finally
  {
    searcherManager.release( searcher );
  }
}

@Test
void readAllDocuments()
{
  LuceneAllDocumentsReader allDocumentsReader = createAllDocumentsReader();
  List<Document> documents = Iterators.asList( allDocumentsReader.iterator() );
  assertEquals( 3, documents.size(), "Should have 1 document from first partition and 2 from second one." );
  assertEquals( "1", documents.get( 0 ).getField( "value" ).stringValue() );
  assertEquals( "3", documents.get( 1 ).getField( "value" ).stringValue() );
  assertEquals( "4", documents.get( 2 ).getField( "value" ).stringValue() );
}

@Test
public void testIgnoreMissing() {
 String[] fields = new String[] {"s", "i", "s2", "o"};
 PdxLuceneSerializer mapper = new PdxLuceneSerializer();
 PdxInstance pdxInstance = mock(PdxInstance.class);
 when(pdxInstance.hasField("s")).thenReturn(true);
 when(pdxInstance.hasField("i")).thenReturn(true);
 when(pdxInstance.hasField("o")).thenReturn(true);
 when(pdxInstance.hasField("o2")).thenReturn(true);
 when(pdxInstance.getField("s")).thenReturn("a");
 when(pdxInstance.getField("i")).thenReturn(5);
 when(pdxInstance.getField("o")).thenReturn(new Object());
 when(pdxInstance.getField("o2")).thenReturn(new Object());
 Document doc = invokeSerializer(mapper, pdxInstance, fields);
 assertEquals(2, doc.getFields().size());
 assertEquals("a", doc.getField("s").stringValue());
 assertEquals(5, doc.getField("i").numericValue());
}

 @Test
 public void testNullField() {
  String[] fields = new String[] {"s", "i"};
  PdxLuceneSerializer mapper = new PdxLuceneSerializer();

  PdxInstance pdxInstance = mock(PdxInstance.class);

  when(pdxInstance.hasField("s")).thenReturn(true);
  when(pdxInstance.hasField("i")).thenReturn(true);
  when(pdxInstance.getField("s")).thenReturn("a");
  when(pdxInstance.getField("i")).thenReturn(null);

  Document doc = invokeSerializer(mapper, pdxInstance, fields);

  assertEquals(1, doc.getFields().size());
  assertEquals("a", doc.getField("s").stringValue());
  assertNull(doc.getField("i"));
 }
}

@Test
public void testWriteFields() {
 String[] fields = new String[] {"s", "i"};
 PdxLuceneSerializer mapper = new PdxLuceneSerializer();
 PdxInstance pdxInstance = mock(PdxInstance.class);
 when(pdxInstance.hasField("s")).thenReturn(true);
 when(pdxInstance.hasField("i")).thenReturn(true);
 when(pdxInstance.getField("s")).thenReturn("a");
 when(pdxInstance.getField("i")).thenReturn(5);
 Document doc = invokeSerializer(mapper, pdxInstance, fields);
 assertEquals(2, doc.getFields().size());
 assertEquals("a", doc.getField("s").stringValue());
 assertEquals(5, doc.getField("i").numericValue());
}

@Test
public void shouldParseRegionValueFieldForString() {
 String[] fields = new String[] {"name", "contacts.name", "contacts.email", "contacts.revenue",
   "contacts.address", "contacts.homepage.id", "contacts.homepage.title",
   "contacts.homepage.content", LuceneService.REGION_VALUE_FIELD};
 FlatFormatSerializer serializer = new FlatFormatSerializer();
 String str = new String("Hello world");
 Document doc1 = SerializerTestHelper.invokeSerializer(serializer, str, fields);
 assertEquals(1, doc1.getFields().size());
 assertEquals("Hello world", doc1.getField(LuceneService.REGION_VALUE_FIELD).stringValue());
}

@Test
public void testIgnoreInvalid() {
 String[] fields = new String[] {"s", "o", "s2"};
 ReflectionLuceneSerializer mapper = new ReflectionLuceneSerializer(Type2.class, fields);
 Type2 type2 = new Type2("a", 1, 2L, 3.0, 4.0f, "b");
 Document doc = invokeSerializer(mapper, type2, fields);
 assertEquals(2, doc.getFields().size());
 assertEquals("a", doc.getField("s").stringValue());
 assertEquals("b", doc.getField("s2").stringValue());
}

@Test
public void shouldNotParseNestedObjectWithoutFields() {
 String[] fields =
   new String[] {"name", "contacts", "contacts.homepage", "contacts.missing", "missing2"};
 FlatFormatSerializer serializer = new FlatFormatSerializer();
 HashSet<Person> contacts1 = new HashSet();
 Person contact1 = new Person("Tommi Jackson", new String[] {"5036330001", "5036330002"}, 1);
 Person contact2 = new Person("Tommi2 Skywalker", new String[] {"5036330003", "5036330004"}, 2);
 contacts1.add(contact1);
 contacts1.add(contact2);
 ArrayList<String> phoneNumbers = new ArrayList();
 phoneNumbers.add("5035330001");
 phoneNumbers.add("5035330002");
 Page[] myHomePages1 = new Page[] {new Page(131), new Page(132)};
 Customer customer = new Customer("Tommy Jackson", phoneNumbers, contacts1, myHomePages1);
 Document doc1 = SerializerTestHelper.invokeSerializer(serializer, customer, fields);
 assertEquals(1, doc1.getFields().size());
 assertEquals("Tommy Jackson", doc1.getField("name").stringValue());
}

@Test
void stringWithMaximumLengthShouldBeAllowed()
{
  String longestString = RandomStringUtils.randomAscii( IndexWriter.MAX_TERM_LENGTH );
  Document document = documentRepresentingProperties( (long) 123, longestString );
  assertEquals( longestString, document.getField( String.key( 0 ) ).stringValue() );
}

@Test
public void verifyFieldCountsInDocument() {
 String[] fields = new String[] {"name", "phoneNumbers", "myHomePages.content", "contacts.name",
   "contacts.email", "contacts.phoneNumbers", "contacts.address", "contacts.revenue",
   "contacts.homepage.id", "contacts.homepage.title", "contacts.homepage.content",
   LuceneService.REGION_VALUE_FIELD};
 FlatFormatSerializer serializer = new FlatFormatSerializer();
 Person contact1 = new Person("Tommi Jackson", new String[] {"5036330001", "5036330002"}, 1);
 Person contact2 = new Person("Tommi2 Skywalker", new String[] {"5036330003", "5036330004"}, 2);
 HashSet<Person> contacts1 = new HashSet();
 contacts1.add(contact1);
 contacts1.add(contact2);
 ArrayList<String> phoneNumbers = new ArrayList();
 phoneNumbers.add("5035330001");
 phoneNumbers.add("5035330002");
 Page[] myHomePages1 = new Page[] {new Page(131), new Page(132)};
 Customer customer = new Customer("Tommy Jackson", phoneNumbers, contacts1, myHomePages1);
 Document doc1 = SerializerTestHelper.invokeSerializer(serializer, customer, fields);
 assertEquals(23, doc1.getFields().size());
 assertEquals("Tommy Jackson", doc1.getField("name").stringValue());
}

@Test
public void shouldIndexPrimitiveStringIfRequested() {
 HeterogeneousLuceneSerializer mapper = new HeterogeneousLuceneSerializer();
 Document doc = SerializerTestHelper.invokeSerializer(mapper, "sample value",
   new String[] {LuceneService.REGION_VALUE_FIELD});
 assertEquals(1, doc.getFields().size());
 assertEquals("sample value", doc.getField(LuceneService.REGION_VALUE_FIELD).stringValue());
}

 @Test
 public void testNullField() {

  String[] fields = new String[] {"s", "o", "s2"};
  ReflectionLuceneSerializer mapper = new ReflectionLuceneSerializer(Type2.class, fields);

  Type2 type2 = new Type2("a", 1, 2L, 3.0, 4.0f, null);

  Document doc = invokeSerializer(mapper, type2, fields);

  assertEquals(1, doc.getFields().size());
  assertEquals("a", doc.getField("s").stringValue());
  assertNull(doc.getField("s2"));
 }
}

  /**
   * This is a test of {@code populateDocument} so it should be rather in {@code AnalyzerGuruTest}
   * however it lacks the pre-requisite indexing phase.
   */
  @Test
  public void testIndexPath() throws IOException {
    SearchEngine instance = new SearchEngine();
    // Use as broad search as possible.
    instance.setFile("c");
    instance.search();
    ScoreDoc[] scoredocs = instance.scoreDocs();
    assertTrue("need some search hits to perform the check",scoredocs.length > 0);
    for (ScoreDoc sd : scoredocs) {
      Document doc = instance.doc(sd.doc);
      assertFalse("PATH field should not contain backslash characters",
          doc.getField(QueryBuilder.PATH).stringValue().contains("\\"));
    }
  }
}

@Test
public void testAllFields() {
 String[] allFields = new String[] {"s", "i", "l", "d", "f", "s2"};
 ReflectionLuceneSerializer mapper1 = new ReflectionLuceneSerializer(Type1.class, allFields);
 ReflectionLuceneSerializer mapper2 = new ReflectionLuceneSerializer(Type2.class, allFields);
 Type1 type1 = new Type1("a", 1, 2L, 3.0, 4.0f);
 Type2 type2 = new Type2("a", 1, 2L, 3.0, 4.0f, "b");
 Document doc1 = invokeSerializer(mapper1, type1, allFields);
 assertEquals(5, doc1.getFields().size());
 assertEquals("a", doc1.getField("s").stringValue());
 assertEquals(1, doc1.getField("i").numericValue());
 assertEquals(2L, doc1.getField("l").numericValue());
 assertEquals(3.0, doc1.getField("d").numericValue());
 assertEquals(4.0f, doc1.getField("f").numericValue());
 Document doc2 = invokeSerializer(mapper2, type2, allFields);
 assertEquals(6, doc2.getFields().size());
 assertEquals("a", doc2.getField("s").stringValue());
 assertEquals("b", doc2.getField("s2").stringValue());
 assertEquals(1, doc2.getField("i").numericValue());
 assertEquals(2L, doc2.getField("l").numericValue());
 assertEquals(3.0, doc2.getField("d").numericValue());
 assertEquals(4.0f, doc2.getField("f").numericValue());
}