/** Load synonyms with the given {@link SynonymMap.Parser} class. */
  private SynonymMap loadSynonyms(
      ResourceLoader loader, String cname, boolean dedup, Analyzer analyzer)
      throws IOException, ParseException {
    CharsetDecoder decoder =
        Charset.forName("UTF-8")
            .newDecoder()
            .onMalformedInput(CodingErrorAction.REPORT)
            .onUnmappableCharacter(CodingErrorAction.REPORT);

    SynonymMap.Parser parser;
    Class<? extends SynonymMap.Parser> clazz = loader.findClass(cname, SynonymMap.Parser.class);
    try {
      parser =
          clazz
              .getConstructor(boolean.class, boolean.class, Analyzer.class)
              .newInstance(dedup, expand, analyzer);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }

    File synonymFile = new File(synonyms);
    if (synonymFile.exists()) {
      decoder.reset();
      parser.parse(new InputStreamReader(loader.openResource(synonyms), decoder));
    } else {
      List<String> files = splitFileNames(synonyms);
      for (String file : files) {
        decoder.reset();
        parser.parse(new InputStreamReader(loader.openResource(file), decoder));
      }
    }
    return parser.build();
  }
  /**
   * Loads the hunspell dictionary and affix files defined in the configuration
   *
   * @param loader ResourceLoader used to load the files
   */
  public void inform(ResourceLoader loader) throws IOException {
    assureMatchVersion();
    String dictionaryArg = args.get(PARAM_DICTIONARY);
    if (dictionaryArg == null) {
      throw new IllegalArgumentException("Parameter " + PARAM_DICTIONARY + " is mandatory.");
    }
    String dictionaryFiles[] = args.get(PARAM_DICTIONARY).split(",");
    String affixFile = args.get(PARAM_AFFIX);
    String pic = args.get(PARAM_IGNORE_CASE);
    if (pic != null) {
      if (pic.equalsIgnoreCase(TRUE)) ignoreCase = true;
      else if (pic.equalsIgnoreCase(FALSE)) ignoreCase = false;
      else
        throw new IllegalArgumentException(
            "Unknown value for " + PARAM_IGNORE_CASE + ": " + pic + ". Must be true or false");
    }

    String strictAffixParsingParam = args.get(PARAM_STRICT_AFFIX_PARSING);
    boolean strictAffixParsing = true;
    if (strictAffixParsingParam != null) {
      if (strictAffixParsingParam.equalsIgnoreCase(FALSE)) strictAffixParsing = false;
      else if (strictAffixParsingParam.equalsIgnoreCase(TRUE)) strictAffixParsing = true;
      else
        throw new IllegalArgumentException(
            "Unknown value for "
                + PARAM_STRICT_AFFIX_PARSING
                + ": "
                + strictAffixParsingParam
                + ". Must be true or false");
    }

    InputStream affix = null;
    List<InputStream> dictionaries = new ArrayList<InputStream>();

    try {
      dictionaries = new ArrayList<InputStream>();
      for (String file : dictionaryFiles) {
        dictionaries.add(loader.openResource(file));
      }
      affix = loader.openResource(affixFile);

      this.dictionary =
          new HunspellDictionary(
              affix, dictionaries, luceneMatchVersion, ignoreCase, strictAffixParsing);
    } catch (ParseException e) {
      throw new IOException(
          "Unable to load hunspell data! [dictionary="
              + args.get("dictionary")
              + ",affix="
              + affixFile
              + "]",
          e);
    } finally {
      IOUtils.closeWhileHandlingException(affix);
      IOUtils.closeWhileHandlingException(dictionaries);
    }
  }
  private Properties canUpdate() {

    try {
      if (conf == null) return null;
      Properties p = new Properties();
      InputStream confStream = loader.openResource(conf);
      p.load(confStream);
      confStream.close();
      String lastupdate = p.getProperty("lastupdate", "0");
      Long t = new Long(lastupdate);

      if (t > this.lastUpdateTime) {
        this.lastUpdateTime = t.longValue();
        String paths = p.getProperty("files");
        if (paths == null || paths.trim().isEmpty()) return null;
        System.out.println("loading conf");
        return p;
      } else {
        this.lastUpdateTime = t.longValue();
        return null;
      }
    } catch (Exception e) {
      System.err.println("ansj parsing conf NullPointerException~~~~~" + e.getMessage());
      return null;
    }
  }
  public void update() throws IOException {
    Properties p = canUpdate();
    if (p != null) {
      List<String> dicPaths = SplitFileNames(p.getProperty("files"));
      List<InputStream> inputStreamList = new ArrayList<InputStream>();
      for (String path : dicPaths) {
        if ((path != null && !path.isEmpty())) {
          InputStream is = loader.openResource(path);

          if (is != null) {
            inputStreamList.add(is);
          }
        }
      }
      if (!inputStreamList.isEmpty()) {
        UserDefineLibrary.reloadMainAndAdd(inputStreamList); // load dic to MainDic
      }
    }
  }
 private List<String> getLines(ResourceLoader loader, String resource) throws IOException {
   return WordlistLoader.getLines(loader.openResource(resource), StandardCharsets.UTF_8);
 }