import org.gradle.internal.file.RandomAccessFileOutputStream;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.channels.FileLock;
import java.nio.channels.OverlappingFileLockException;

public class LockInfoAccess {

import me.champeau.gradle.japicmp.report.ViolationCheckContext;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.UncheckedIOException;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.regex.Pattern;

package org.gradle.cache.internal.btree;

import com.google.common.io.CountingOutputStream;
import org.gradle.internal.file.RandomAccessFileOutputStream;

import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.RandomAccessFile;

/**
 * Allows a stream of bytes to be written to a particular location of some backing byte stream.
 */
class ByteOutput {

package org.gradle.cache.internal.locklistener;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketAddress;
import java.net.SocketException;
import java.util.Set;

import static org.gradle.cache.internal.locklistener.FileLockPacketType.LOCK_RELEASE_CONFIRMATION;

import org.gradle.caching.BuildCacheException;
import org.gradle.caching.BuildCacheKey;
import org.gradle.caching.BuildCacheService;

import java.io.Closeable;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * Left to keep H2BuildCacheService logic
 */
public interface StatefulNextGenBuildCacheService extends BuildCacheService, Closeable {
    /**

import org.gradle.api.tasks.PathSensitivity;
import org.gradle.internal.fingerprint.FileNormalizer;

import java.util.Locale;

// TODO Break this up between simple normalizers and Java classpath normalizers
//      The latter should be moved to :normalization-java
public enum InputNormalizer implements FileNormalizer {
    ABSOLUTE_PATH(false),
    RELATIVE_PATH(false),
    NAME_ONLY(false),

 */
package org.gradle.cache.internal;

import com.google.common.util.concurrent.Striped;
import org.gradle.internal.UncheckedException;

import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Supplier;

/**
 * Synchronizes access to some resource, by making sure that 2 threads do not try to produce it at the same time.

import me.champeau.gradle.japicmp.report.PostProcessViolationsRule;
import me.champeau.gradle.japicmp.report.ViolationCheckContextWithViolations;
import org.gradle.util.internal.CollectionUtils;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import static gradlebuild.binarycompatibility.upgrades.UpgradedProperties.OLD_ACCESSORS_OF_UPGRADED_PROPERTIES;

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

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class FreeListBlockStore implements BlockStore {
    private final BlockStore store;
    private final BlockStore freeListStore;

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.model;

import java.util.Map;
import java.util.function.Function;

/**
 * A cache backed by calculated values. This map is thread-safe.
 */
public interface CalculatedValueCache<K, V> {

    /**