import org.codelibs.fess.crawler.exception.ExtractException;

/**
 * @author shinsuke
 *
 */
public class TextExtractor extends AbstractExtractor {

    protected String encoding = Constants.UTF_8;

    @Override
    public ExtractData getText(final InputStream in, final Map<String, String> params) {
        if (in == null) {
            throw new CrawlerSystemException("The inputstream is null.");
        }
        try {

public class SitemapsRule extends RegexRule {
    /**
     *
     */
    private static final long serialVersionUID = 1L;

    private static final Logger logger = LoggerFactory.getLogger(SitemapsRule.class);

    @Override
    public boolean match(final ResponseData responseData) {
        if (super.match(responseData)) {
            try (final InputStream is = responseData.getResponseBody()) {

import java.net.UnknownHostException;

import org.apache.http.conn.DnsResolver;

public class IdnDnsResolver implements DnsResolver {

    protected int flag = 0;

    protected String encoding = "UTF-8";

    @Override
    public InetAddress[] resolve(final String host) throws UnknownHostException {
        return InetAddress.getAllByName(toAscii(host));
    }

    protected String decode(final String host) {

    for (call in networkRequests) {
      call.enqueue(
        object : Callback {
          override fun onFailure(
            call: Call,
            e: IOException,
          ) {
            synchronized(failures) {
              failures.add(e)
            }
            latch.countDown()
          }

          override fun onResponse(
            call: Call,
            response: Response,
          ) {

        // TODO set up opensearch and dictionaryManager
        synonymFile = new SynonymFile("1", file1.getAbsolutePath(), new Date());
    }

    @Override
    public void tearDown() throws Exception {
        file1.delete();
    }
    */

    @Override
    public void setUp() throws Exception {
        super.setUp();
        synonymFile = new SynonymFile("1", "dummy", new Date());

    }
  }

  private enum PlatformSpecificExceptionBatch {
    PLATFORM {
      @GwtIncompatible
      @J2ktIncompatible
      @Override
      // returns the types available in "normal" environments
      ImmutableMap<Class<? extends Throwable>, Predicate<Throwable>> exceptions() {
        return ImmutableMap.of(
            InvocationTargetException.class,

    holder.string = "one";
    Entry<String, Integer> entry =
        new AbstractMapEntry<String, Integer>() {
          @Override
          public String getKey() {
            return holder.string;
          }

          @Override
          public Integer getValue() {
            return 1;
          }
        };

    builder.put(entry);
    holder.string = "two";

        return this.specialName;
    }


    /**
     * @return the expandedNames
     */
    public final String[] getExpandedNames () {
        return this.expandedNames;
    }


    @Override
    public int decode ( byte[] buffer, int bufferIndex, int len ) {
        int start = bufferIndex;

        this.version = SMBUtil.readInt2(buffer, bufferIndex);
        if ( this.version != 3 && this.version != 1 ) {

    private AsCharSink(Charset charset) {
      this.charset = checkNotNull(charset);
    }

    @Override
    public Writer openStream() throws IOException {
      return new OutputStreamWriter(ByteSink.this.openStream(), charset);
    }

    @Override
    public String toString() {
      return ByteSink.this.toString() + ".asCharSink(" + charset + ")";
    }
  }

     * array directly, saving a method call.
     */
    @Override
    public String escape(String s) {
      int slen = s.length();
      for (int index = 0; index < slen; index++) {
        char c = s.charAt(index);
        if (c < replacements.length && replacements[c] != null) {
          return escapeSlow(s, index);
        }
      }
      return s;
    }

    @Override
    @CheckForNull
    protected char[] escape(char c) {