FileSystem.java

package com.osroyale.fs.cache;
 
import com.google.common.base.Preconditions;
import com.osroyale.fs.cache.archive.Archive;
 
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SeekableByteChannel;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Objects;
import java.util.zip.CRC32;
 
import static java.nio.file.StandardOpenOption.READ;
import static java.nio.file.StandardOpenOption.WRITE;

 
public final class FileSystem {

    public static final int CONFIG_INDEX = 0;

    public static final int MODEL_INDEX = 1;

    public static final int ANIMATION_INDEX = 2;

    public static final int MIDI_INDEX = 3;

    public static final int MAP_INDEX = 4;

    public static final int TITLE_ARCHIVE = 1;

    public static final int CONFIG_ARCHIVE = 2;

    public static final int INTERFACE_ARCHIVE = 3;

    public static final int MEDIA_ARCHIVE = 4;

    public static final int MANIFEST_ARCHIVE = 5;

    public static final int TEXTURES_ARCHIVE = 6;

    public static final int WORD_ARCHIVE = 7;

    public static final int SOUND_ARCHIVE = 8;

    private static final int MAXIMUM_ARCHIVES = 9;

    private static final int MAXIMUM_INDICES = 256;

    private static final String DATA_PREFIX = "main_file_cache.dat";

    private static final String INDEX_PREFIX = "main_file_cache.idx";

    private final Cache[] caches;

    private final Archive[] archives;

    private ByteBuffer archiveHashes;

    private FileSystem(Cache[] caches, Archive[] archives) {
        this.caches = caches;
        this.archives = archives;
    }

    public static FileSystem create(String directory) throws IOException {
        Path root = Paths.get(directory);
        Preconditions.checkArgument(Files.isDirectory(root), "Supplied path must be a directory! " + root);
 
        Path data = root.resolve(DATA_PREFIX);
        Preconditions.checkArgument(Files.exists(data), "No data file found in the specified path!");
 
        SeekableByteChannel dataChannel = Files.newByteChannel(data, READ, WRITE);
 
        Cache[] caches = new Cache[MAXIMUM_INDICES];
        Archive[] archives = new Archive[MAXIMUM_ARCHIVES];
 
        for (int index = 0; index < caches.length; index++) {
            Path path = root.resolve(INDEX_PREFIX + index);
            if (Files.exists(path)) {
                SeekableByteChannel indexChannel = Files.newByteChannel(path, READ, WRITE);
                caches[index] = new Cache(dataChannel, indexChannel, index);
            }
        }
 
        // We don't use index 0
        for (int id = 1; id < archives.length; id++) {
            Cache cache = Objects.requireNonNull(caches[CONFIG_INDEX], "Configuration cache is null - unable to decode archives");
            archives[id] = Archive.decode(cache.get(id));
        }
 
        return new FileSystem(caches, archives);
    }

    public Archive getArchive(int id) {
        Preconditions.checkElementIndex(id, archives.length);
        return Objects.requireNonNull(archives[id]);
    }

    public Cache getCache(int id) {
        Preconditions.checkElementIndex(id, caches.length);
        return Objects.requireNonNull(caches[id]);
    }

    public ByteBuffer getFile(int cacheId, int indexId) throws IOException {
        Cache cache = getCache(cacheId);
        synchronized (cache) {
            return cache.get(indexId);
        }
    }

    public ByteBuffer getArchiveHashes() throws IOException {
        synchronized (this) {
            if (archiveHashes != null) {
                return archiveHashes.duplicate();
            }
        }
 
        int[] crcs = new int[MAXIMUM_ARCHIVES];
 
        CRC32 crc32 = new CRC32();
        for (int file = 1; file < crcs.length; file++) {
            crc32.reset();
 
            ByteBuffer buffer = getFile(CONFIG_INDEX, file);
            crc32.update(buffer);
 
            crcs[file] = (int) crc32.getValue();
        }
 
        ByteBuffer buffer = ByteBuffer.allocate((crcs.length + 1) * Integer.BYTES);
 
        int hash = 1234;
        for (int crc : crcs) {
            hash = (hash << 1) + crc;
            buffer.putInt(crc);
        }
 
        buffer.putInt(hash);
        buffer.flip();
 
        synchronized (this) {
            archiveHashes = buffer.asReadOnlyBuffer();
            return archiveHashes.duplicate();
        }
    }
 
}