return this.wrapper;
        }
    }


    protected CIFSContext failHostInjecting ( CIFSContext ctx, final String replacement ) throws UnknownHostException {

        final NameServiceClient nscl = ctx.getNameServiceClient();

        final NameServiceClient wrapper = new DelegatingNameServiceClient(nscl) {

            private InetAddress replacementINET = InetAddress.getByName(replacement);

        private BufferedReader br;

        private final List<String> list = new LinkedList<>();

        private final int maxLineBuffer;

        public InputStreamThread(final InputStream is, final String charset, final int maxOutputLineBuffer) {
            try {
                br = new BufferedReader(new InputStreamReader(is, charset));
            } catch (final UnsupportedEncodingException e) {

import org.dbflute.optional.OptionalEntity;

public class SynonymFile extends DictionaryFile<SynonymItem> {
    private static final String SYNONYM = "synonym";

    List<SynonymItem> synonymItemList;

    public SynonymFile(final String id, final String path, final Date timestamp) {
        super(id, path, timestamp);
    }

    @Override
    public String getType() {
        return SYNONYM;
    }

 *
 * @author Kevin Bourrillion
 * @author Chris Povirk
 */
final class InterruptionUtil {
  private static final Logger logger = Logger.getLogger(InterruptionUtil.class.getName());

  /** Runnable which will interrupt the target thread repeatedly when run. */
  private static final class Interruptenator implements Runnable {
    private final long everyMillis;
    private final Thread interruptee;
    private volatile boolean shouldStop = false;

                count++;
            }
            final String message = "Failed to access to " + request.getUrl()
                    + exceptionList.stream().map(e -> "; " + e.getMessage()).collect(Collectors.joining());
            throw new MultipleCrawlingAccessException(message, exceptionList.toArray(new Throwable[exceptionList.size()]));
        } finally {
            if (listener != null) {

  public static final Integer eight = 8;
  public static final Integer nine = 9;
  public static final Integer m1 = -1;
  public static final Integer m2 = -2;
  public static final Integer m3 = -3;
  public static final Integer m4 = -4;
  public static final Integer m5 = -5;
  public static final Integer m6 = -6;
  public static final Integer m10 = -10;

  /**

      implements Serializable {
    private static final long serialVersionUID = 3;

    final Strength keyStrength;
    final Strength valueStrength;
    final Equivalence<Object> keyEquivalence;
    final Equivalence<Object> valueEquivalence;
    final int concurrencyLevel;

    transient ConcurrentMap<K, V> delegate;

    AbstractSerializationProxy(

          val story =
            readStory(storyInputStream.source().buffer())
              .copy(fileName = storyResourceName)
          result.add(story)
          i++
        }
      } finally {
        storyInputStream.close()
      }
    }

    if (result.isEmpty()) {
      // missing files
      result.add(Story.MISSING)
    }

    return result
  }

    }

    protected void doCrawl(final String sessionId, final List<DataConfig> configList) {
        final int multiprocessCrawlingCount = ComponentUtil.getFessConfig().getCrawlingThreadCount();

        final SystemHelper systemHelper = ComponentUtil.getSystemHelper();
        final long startTime = systemHelper.getCurrentTimeAsLong();

  virtual void Release() = 0;

  // Creates an operation builder and ties it to this context.
  // The returned object can be used for setting operation's attributes,
  // adding inputs and finally executing (immediately or lazily as in tracing)
  // it in this context.
  virtual AbstractOperation* CreateOperation() = 0;

  // Registers a function with this context, after this the function is