continue;
                }

                String reading = getReadingFromAttribute(stream);
                if (Strings.isNullOrEmpty(reading)) {
                    reading = transliterator.transliterate(att.toString());
                }
                kanaBuf.append(reading);
                offset += term.length();
            }
        }

 * <li>{@link #badWords} - List of bad words.</li>
 * <li>{@link #parallel} - Flag for parallel processing.</li>
 * <li>{@link #readingConverter} - Reading converter.</li>
 * <li>{@link #contentsReadingConverter} - Contents reading converter.</li>
 * <li>{@link #normalizer} - Normalizer.</li>
 * <li>{@link #analyzer} - Suggest analyzer.</li>
 * <li>{@link #contentsParser} - Contents parser.</li>

     */
    protected ZipFileUtil() {
    }

    /**
     * Creates and returns a <code>ZipFile</code> for reading the specified Zip file.
     *
     * @param file
     *            File path. Must not be {@literal null} or an empty string.
     * @return A <code>ZipFile</code> for reading the specified Zip file.
     */
    public static ZipFile create(final String file) {
        assertArgumentNotEmpty("file", file);

    }

    /**
     * Sets the reading converter.
     * @param readingConverter The reading converter.
     * @return This builder instance.
     */
    public SuggesterBuilder readingConverter(final ReadingConverter readingConverter) {
        this.readingConverter = readingConverter;
        return this;
    }

    /**
     * Sets the contents reading converter.

      @SuppressWarnings("unchecked") // reading data stored by writeMap
      K key = (K) stream.readObject();
      @SuppressWarnings("unchecked") // reading data stored by writeMap
      V value = (V) stream.readObject();
      map.put(key, value);
    }
  }

  /**
   * Stores the contents of a multiset in an output stream, as part of serialization. It does not

                if (readings != null && readings.length > i && readings[i].length > 0) {
                    for (final String reading : readings[i]) {
                        if (!l.contains(reading)) {
                            l.add(reading);
                        }
                    }
                }

                wordsList.add(word);

        String[][] readings = { { "reading" } };
        String[] fields = { "field" };

        return new SuggestItem(texts, readings, fields, 1L, 1L, 1.0f, tags, new String[0], new String[0], SuggestItem.Kind.DOCUMENT);
    }

    private SuggestItem createItemWithRoles(String text, String... roles) {
        String[] texts = { text };
        String[][] readings = { { "reading" } };
        String[] fields = { "field" };

 *       normalization, contents, and contents reading) for a specific field.</li>
 * </ul>
 *
 * @see SuggestAnalyzer
 * @see FieldAnalyzerMapping
 */
public class AnalyzerSettings {
    /** Analyzer name for reading. */
    public static final String READING_ANALYZER = "reading_analyzer";
    /** Analyzer name for reading term. */

                        final String reading = readingList.get(readingCount);
                        if (i + 1 == queries.length && prefixQuery) {
                            readingQueryBuilder.should(QueryBuilders.prefixQuery(fieldName, reading));
                        } else {
                            readingQueryBuilder.should(QueryBuilders.termQuery(fieldName, reading));
                        }
                    }

     * @param langFieldName The name of the field that contains language information.
     * @param readingConverter The converter to use for reading fields.
     * @param contentsReadingConverter The converter to use for reading content fields.
     * @param normalizer The normalizer to use for normalizing field values.
     * @param analyzer The analyzer to use for analyzing field values.