import com.google.common.annotations.J2ktIncompatible;
import java.io.Closeable;
import java.io.Flushable;
import java.io.IOException;
import java.io.Writer;
import javax.annotation.CheckForNull;

/**
 * Writer that places all output on an {@link Appendable} target. If the target is {@link Flushable}
 * or {@link Closeable}, flush()es and close()s will also be delegated to the target.
 *
 * @author Alan Green

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.suggest.index.contents.document;

import java.io.Closeable;
import java.util.Map;

public interface DocumentReader extends Closeable {
    Map<String, Object> read();

    @Override
    void close();

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.suggest.index.contents.querylog;

import java.io.Closeable;

public interface QueryLogReader extends Closeable {
    QueryLog read();

    @Override
    void close();

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.security.internal;

import java.io.Closeable;

public interface PublicKeyService extends Closeable {
    void findByLongId(long keyId, PublicKeyResultBuilder builder);
    void findByFingerprint(byte[] fingerprint, PublicKeyResultBuilder builder);

     * in which {@code Cursor} is {@code Closeable}. To support older versions, pass a wrapper
     * {@code Closeable} with a method reference like {@code cursor::close}.
     *
     * <p>Note that this method is still binary-compatible between flavors because the erasure of
     * its parameter type is {@code Object}, not {@code AutoCloseable} or {@code Closeable}.
     *
     * @param closeable the object to be closed (see notes above)

        registry.add(Closeable, {
            instant.closing
            thread.blockUntil.lookupDone
        } as Closeable)

        when:
        async {
            start() {
                registry.close()
            }
            start {
                thread.blockUntil.closing
                try {
                    registry.get(Closeable)
                } finally {

     * in which {@code Cursor} is {@code Closeable}. To support older versions, pass a wrapper
     * {@code Closeable} with a method reference like {@code cursor::close}.
     *
     * <p>Note that this method is still binary-compatible between flavors because the erasure of
     * its parameter type is {@code Object}, not {@code AutoCloseable} or {@code Closeable}.
     *
     * @param closeable the object to be closed (see notes above)

 * limitations under the License.
 */

package org.gradle.internal.jvm.inspection;

import javax.annotation.Nonnull;
import java.io.Closeable;
import java.io.IOException;

public class InvalidJvmInstallationCacheInvalidator implements Closeable {

    @Nonnull
    private final ConditionalInvalidation<JvmInstallationMetadata> cache;

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.cache;

import java.io.Closeable;
import java.io.File;

public interface FileLock extends Closeable, FileAccess {
    /**
     * Returns true if the most recent mutation method ({@link #updateFile(Runnable)} or {@link #writeFile(Runnable)} attempted by any process succeeded

import org.gradle.cache.PersistentCache;
import org.gradle.cache.scopes.GlobalScopedCacheBuilderFactory;

import java.io.Closeable;
import java.io.File;
import java.util.Collections;
import java.util.List;

public class DefaultGeneratedGradleJarCache implements GeneratedGradleJarCache, Closeable, GlobalCache {
    private final PersistentCache cache;
    private final String gradleVersion;