Java 类org.apache.lucene.analysis.hunspell.Dictionary 实例源码

public HunspellService(final Settings settings, final Environment env, final Map<String, Dictionary> knownDictionaries)
        throws IOException {
    super(settings);
    this.knownDictionaries = Collections.unmodifiableMap(knownDictionaries);
    this.hunspellDir = resolveHunspellDirectory(env);
    this.defaultIgnoreCase = HUNSPELL_IGNORE_CASE.get(settings);
    this.loadingFunction = (locale) -> {
        try {
            return loadDictionary(locale, settings, env);
        } catch (Exception e) {
            throw new IllegalStateException("failed to load hunspell dictionary for locale: " + locale, e);
        }
    };
    if (!HUNSPELL_LAZY_LOAD.get(settings)) {
        scanAndLoadDictionaries();
    }

}

public void testLocaleDirectoryWithLocaleSpecificConfig() throws Exception {
    Settings settings = Settings.builder()
            .put(Environment.PATH_CONF_SETTING.getKey(), getDataPath("/indices/analyze/conf_dir"))
            .put(HUNSPELL_LAZY_LOAD.getKey(), randomBoolean())
            .put(HUNSPELL_IGNORE_CASE.getKey(), true)
            .put("indices.analysis.hunspell.dictionary.en_US.strict_affix_parsing", false)
            .put("indices.analysis.hunspell.dictionary.en_US.ignore_case", false)
            .put(Environment.PATH_HOME_SETTING.getKey(), createTempDir())
            .build();

    Dictionary dictionary = new HunspellService(settings, new Environment(settings), emptyMap()).getDictionary("en_US");
    assertThat(dictionary, notNullValue());
    assertFalse(dictionary.getIgnoreCase());

    // testing that dictionary specific settings override node level settings
    dictionary = new HunspellService(settings, new Environment(settings), emptyMap()).getDictionary("en_US_custom");
    assertThat(dictionary, notNullValue());
    assertTrue(dictionary.getIgnoreCase());
}

@Inject
public HunspellService(final Settings settings, final Environment env, final Map<String, Dictionary> knownDictionaries) throws IOException {
    super(settings);
    this.knownDictionaries = knownDictionaries;
    this.hunspellDir = resolveHunspellDirectory(settings, env);
    this.defaultIgnoreCase = settings.getAsBoolean(HUNSPELL_IGNORE_CASE, false);
    dictionaries = CacheBuilder.newBuilder().build(new CacheLoader<String, Dictionary>() {
        @Override
        public Dictionary load(String locale) throws Exception {
            Dictionary dictionary = knownDictionaries.get(locale);
            if (dictionary == null) {
                dictionary = loadDictionary(locale, settings, env);
            }
            return dictionary;
        }
    });
    if (!settings.getAsBoolean(HUNSPELL_LAZY_LOAD, false)) {
        scanAndLoadDictionaries();
    }
}

/**
 * Returns the hunspell dictionary for the given locale.
 *
 * @param locale The name of the locale
 */
public Dictionary getDictionary(String locale) {
    Dictionary dictionary = knownDictionaries.get(locale);
    if (dictionary == null) {
        dictionary = dictionaries.computeIfAbsent(locale, loadingFunction);
    }
    return dictionary;
}

public void testLocaleDirectoryWithNodeLevelConfig() throws Exception {
    Settings settings = Settings.builder()
            .put(Environment.PATH_CONF_SETTING.getKey(), getDataPath("/indices/analyze/conf_dir"))
            .put(HUNSPELL_LAZY_LOAD.getKey(), randomBoolean())
            .put(HUNSPELL_IGNORE_CASE.getKey(), true)
            .put(Environment.PATH_HOME_SETTING.getKey(), createTempDir())
            .build();

    Dictionary dictionary = new HunspellService(settings, new Environment(settings), emptyMap()).getDictionary("en_US");
    assertThat(dictionary, notNullValue());
    assertTrue(dictionary.getIgnoreCase());
}

@BeforeClass
public static void beforeClass() throws Exception {
  InputStream affixStream = TestStemmer.class.getResourceAsStream("simple.aff");
  InputStream dictStream = TestStemmer.class.getResourceAsStream("simple.dic");
  try {
    dictionary = new Dictionary(affixStream, dictStream);
  } finally {
    IOUtils.closeWhileHandlingException(affixStream, dictStream);
  }
}

@Override public Object create(Random random) {
  // TODO: make nastier
  InputStream affixStream = TestHunspellStemFilter.class.getResourceAsStream("simple.aff");
  InputStream dictStream = TestHunspellStemFilter.class.getResourceAsStream("simple.dic");
  try {
   return new Dictionary(affixStream, dictStream);
  } catch (Exception ex) {
    Rethrow.rethrow(ex);
    return null; // unreachable code
  }
}

/**
 * Loads the hunspell dictionary for the given local.
 *
 * @param locale       The locale of the hunspell dictionary to be loaded.
 * @param nodeSettings The node level settings
 * @param env          The node environment (from which the conf path will be resolved)
 * @return The loaded Hunspell dictionary
 * @throws Exception when loading fails (due to IO errors or malformed dictionary files)
 */
private Dictionary loadDictionary(String locale, Settings nodeSettings, Environment env) throws Exception {
    if (logger.isDebugEnabled()) {
        logger.debug("Loading hunspell dictionary [{}]...", locale);
    }
    Path dicDir = hunspellDir.resolve(locale);
    if (FileSystemUtils.isAccessibleDirectory(dicDir, logger) == false) {
        throw new ElasticsearchException(String.format(Locale.ROOT, "Could not find hunspell dictionary [%s]", locale));
    }

    // merging node settings with hunspell dictionary specific settings
    Settings dictSettings = HUNSPELL_DICTIONARY_OPTIONS.get(nodeSettings);
    nodeSettings = loadDictionarySettings(dicDir, dictSettings.getByPrefix(locale + "."));

    boolean ignoreCase = nodeSettings.getAsBoolean("ignore_case", defaultIgnoreCase);

    Path[] affixFiles = FileSystemUtils.files(dicDir, "*.aff");
    if (affixFiles.length == 0) {
        throw new ElasticsearchException(String.format(Locale.ROOT, "Missing affix file for hunspell dictionary [%s]", locale));
    }
    if (affixFiles.length != 1) {
        throw new ElasticsearchException(String.format(Locale.ROOT, "Too many affix files exist for hunspell dictionary [%s]", locale));
    }
    InputStream affixStream = null;

    Path[] dicFiles = FileSystemUtils.files(dicDir, "*.dic");
    List<InputStream> dicStreams = new ArrayList<>(dicFiles.length);
    try {

        for (int i = 0; i < dicFiles.length; i++) {
            dicStreams.add(Files.newInputStream(dicFiles[i]));
        }

        affixStream = Files.newInputStream(affixFiles[0]);

        try (Directory tmp = new SimpleFSDirectory(env.tmpFile())) {
            return new Dictionary(tmp, "hunspell", affixStream, dicStreams, ignoreCase);
        }

    } catch (Exception e) {
        logger.error((Supplier<?>) () -> new ParameterizedMessage("Could not load hunspell dictionary [{}]", locale), e);
        throw e;
    } finally {
        IOUtils.close(affixStream);
        IOUtils.close(dicStreams);
    }
}

public void registerHunspellDictionary(String name, Dictionary dictionary) {
    hunspellDictionaries.registerExtension(name, dictionary);
}

public HunspellService(final Settings settings, final Environment env) throws IOException {
    this(settings, env, Collections.<String, Dictionary>emptyMap());
}

/**
 * Returns the hunspell dictionary for the given locale.
 *
 * @param locale The name of the locale
 */
public Dictionary getDictionary(String locale) {
    return dictionaries.getUnchecked(locale);
}