* Executor, and sequentially such that no two will ever be running at the same time.
 *
 * <p>Tasks submitted to {@link #execute(Runnable)} are executed in FIFO order.
 *
 * <p>The execution of tasks is done by one thread as long as there are tasks left in the queue.
 * When a task is {@linkplain Thread#interrupt interrupted}, execution of subsequent tasks
 * continues. See {@link QueueWorker#workOnQueue} for details.
 *

package org.codelibs.fess.app.pager;

import java.io.Serializable;
import java.util.List;

import org.codelibs.fess.util.ComponentUtil;

public class SynonymPager implements Serializable {

    private static final long serialVersionUID = 1L;

    private int allRecordCount;

    private int allPageCount;

    private boolean existPrePage;

    private boolean existNextPage;

    private List<Integer> pageNumberList;

import org.codelibs.core.lang.MethodUtil;

/**
 * {@link NoSuchMethodException}をラップする例外です。
 *
 * @author higa
 */
public class NoSuchMethodRuntimeException extends ClRuntimeException {

    private static final long serialVersionUID = -5673845060079098617L;

    private final Class<?> targetClass;

    private final String methodName;

    private final Class<?>[] argTypes;

    /**

        return 0;
    }
    int writeDataWireFormat( byte[] dst, int dstIndex ) {
        if(( dst.length - dstIndex ) < pipeDataLen ) {
            if( log.level >= 3 )
                log.println( "TransCallNamedPipe data too long for buffer" );
            return 0;
        }
        System.arraycopy( pipeData, pipeDataOff, dst, dstIndex, pipeDataLen );
        return pipeDataLen;
    }

 *
 */
public class MojoFailureException extends AbstractMojoExecutionException {
    /**
     * Construct a new <code>MojoFailureException</code> exception providing the source and a short and long message:
     * these messages are used to improve the message written at the end of Maven build.
     *
     * @param source
     * @param shortMessage
     * @param longMessage
     */

      object : Source {
        var closed = false

        override fun close() {
          closed = true
        }

        override fun read(
          sink: Buffer,
          byteCount: Long,
        ): Long {
          check(!closed)
          return data.read(sink, byteCount)
        }

        override fun timeout(): Timeout {
          return Timeout.NONE
        }
      }

  override fun getCipherSuite(): String {
    throw UnsupportedOperationException()
  }

  override fun getCreationTime(): Long {
    throw UnsupportedOperationException()
  }

  override fun getId(): ByteArray {
    throw UnsupportedOperationException()
  }

  override fun getLastAccessedTime(): Long {
    throw UnsupportedOperationException()
  }

  override fun getLocalCertificates(): Array<Certificate> {

  }

  @Override
  public int read(byte[] b, int off, int len) throws IOException {
    throwIf(closed);
    throwIf(READ_THROWS);
    return in.read(b, off, len);
  }

  @Override
  public long skip(long n) throws IOException {
    throwIf(closed);
    throwIf(SKIP_THROWS);
    return in.skip(n);
  }

  @Override
  public int available() throws IOException {
    throwIf(closed);

    private static final Logger log = LoggerFactory.getLogger(SmbComClose.class);

    private int fid;
    private long lastWriteTime;


    /**
     * 
     * @param config
     * @param fid
     * @param lastWriteTime
     */
    public SmbComClose ( Configuration config, int fid, long lastWriteTime ) {
        super(config, SMB_COM_CLOSE);
        this.fid = fid;
        this.lastWriteTime = lastWriteTime;

  private static final double[] VALUES = {
    Double.NEGATIVE_INFINITY,
    -Double.MAX_VALUE,
    (double) Long.MIN_VALUE,
    (double) Integer.MIN_VALUE,
    -Math.PI,
    -1.0,
    -Double.MIN_VALUE,
    -0.0,
    +0.0,
    Double.MIN_VALUE,
    1.0,
    Math.PI,
    (double) Integer.MAX_VALUE,
    (double) Long.MAX_VALUE,
    Double.MAX_VALUE,
    Double.POSITIVE_INFINITY,
    Double.NaN,
    Float.MAX_VALUE,