}

  @ExperimentalOkHttpApi
  companion object {
    /**
     * Enqueued on shutdown to release threads waiting on [dispatch]. Note that this response
     * isn't transmitted because the connection is closed before this response is returned.
     */
    private val DEAD_LETTER = MockResponse(code = HTTP_UNAVAILABLE)

    private val logger = Logger.getLogger(QueueDispatcher::class.java.name)
  }

  fun request(): Request

  /**
   * Immediately and violently release resources held by this event source. This does nothing if
   * the event source has already been closed or canceled.
   */
  fun cancel()

  fun interface Factory {
    /**
     * Creates a new event source and immediately returns it. Creating an event source initiates an

func (c *lockRESTClient) IsOnline() bool {
	return c.connection.State() == grid.StateConnected
}

// Not a local locker
func (c *lockRESTClient) IsLocal() bool {
	return false
}

// Close - marks the client as closed.
func (c *lockRESTClient) Close() error {
	return nil
}

// String - returns the remote host of the connection.
func (c *lockRESTClient) String() string {
	return c.connection.Remote
}

public class MavenRepositorySystemSupplier implements Supplier<RepositorySystem> {
    private final AtomicBoolean closed = new AtomicBoolean(false);

    public MavenRepositorySystemSupplier() {}

    private void checkClosed() {
        if (closed.get()) {
            throw new IllegalStateException("Supplier is closed");
        }
    }

    private PathProcessor pathProcessor;

   *
   * To avoid leaking resources callers should close the [Response] which in turn will close the
   * underlying [ResponseBody].
   *
   * ```java
   * // ensure the response (and underlying response body) is closed
   * try (Response response = client.newCall(request).execute()) {
   *   ...
   * }
   * ```
   *
   * The caller may read the response body with the response's [Response.body] method. To avoid

                  multiset = multiset.tailMultiset(firstInclusive, BoundType.CLOSED);
                } else if (from == Bound.EXCLUSIVE) {
                  multiset = multiset.tailMultiset(firstExclusive, BoundType.OPEN);
                }

                if (to == Bound.INCLUSIVE) {
                  multiset = multiset.headMultiset(lastInclusive, BoundType.CLOSED);
                } else if (to == Bound.EXCLUSIVE) {

	}
	return target.send(eventData)
}

// IsConnErr - To detect a connection error.
func IsConnErr(err error) bool {
	return xnet.IsConnRefusedErr(err) || err.Error() == "sql: database is closed" || err.Error() == "sql: statement is closed" || err.Error() == "invalid connection"
}

// send - sends an event to the PostgreSQL.
func (target *PostgreSQLTarget) send(eventData event.Event) error {

    /**
     * Get the next set of changes
     * 
     * Will block until the server returns a set of changes that match the given filter. The file will be automatically
     * opened if it is not and should be closed with {@link #close()} when no longer
     * needed.
     * 
     * Closing the context should cancel a pending notify request, but that does not seem to work reliable in all
     * implementations.
     * 

import japicmp.model.JApiMethod
import javassist.bytecode.SourceFileAttribute
import java.io.File


/**
 * Repository of sources for binary compatibility checks.
 *
 * `WARN` Holds resources open for performance, must be closed after use.
 */
class BinaryCompatibilityRepository internal constructor(

    private
    val sources: SourcesRepository

) : AutoCloseable {

    companion object {

        @JvmStatic

        }
        catch ( SmbException se ) {
            throw seToIoe(se);
        }
    }


    @Override
    public void close () {
        // ignore, the shared file descriptor is closed by the pipe handle
    }