public void loadMetaData() throws IOException {
pageFile.seek(offset);
nextPageId = pageFile.readInt();
currentFill = pageFile.readInt();
bloomfilter = pageFile.readInt();
type = pageFile.readByte();
}
private Part read() throws IOException {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < PNUMLEN; i++) sb.append(raf.readChar());
String partnum = sb.toString().trim();
sb.setLength(0);
for (int i = 0; i < DESCLEN; i++) sb.append(raf.readChar());
String partdesc = sb.toString().trim();
int qty = raf.readInt();
int ucost = raf.readInt();
return new Part(partnum, partdesc, qty, ucost);
}
public static void loadAllOpenLevels(Player player, RandomAccessFile loadfile)
throws IOException {
System.out.printf("Entering map loader at %d!\n", loadfile.getFilePointer());
int mapsToLoad = loadfile.readInt();
for (int x = 0; x < mapsToLoad; x++) {
System.out.printf("Loading a map at %d!\n", loadfile.getFilePointer());
int layer = loadfile.readInt();
System.out.printf("Looks like it's map %d!\n", layer);
loadMap(layer, player, loadfile);
}
}
private boolean readIndex() {
if (triedToReadIndex || !usePreindexedCache) {
return false;
}
boolean ret = false;
synchronized (this) {
triedToReadIndex = true;
RandomAccessFile raf = null;
try {
File indexFileName = getIndexFile();
raf = new RandomAccessFile(indexFileName, "r");
long fileStamp = raf.readLong();
if (zipFile.lastModified() != fileStamp) {
ret = false;
} else {
directories = new LinkedHashMap<RelativeDirectory, DirectoryEntry>();
int numDirs = raf.readInt();
for (int nDirs = 0; nDirs < numDirs; nDirs++) {
int dirNameBytesLen = raf.readInt();
byte[] dirNameBytes = new byte[dirNameBytesLen];
raf.read(dirNameBytes);
RelativeDirectory dirNameStr = getRelativeDirectory(new String(dirNameBytes, "UTF-8"));
DirectoryEntry de = new DirectoryEntry(dirNameStr, this);
de.numEntries = raf.readInt();
de.writtenOffsetOffset = raf.readLong();
directories.put(dirNameStr, de);
}
ret = true;
zipFileLastModified = fileStamp;
}
} catch (Throwable t) {
// Do nothing
} finally {
if (raf != null) {
try {
raf.close();
} catch (Throwable tt) {
// Do nothing
}
}
}
if (ret == true) {
readFromIndex = true;
}
}
return ret;
}
public IndexEntry(final Index index, final RandomAccessFile raf) throws IOException {
this.index = index;
token = raf.readUTF();
startRow = raf.readInt();
numRows = raf.readInt();
final boolean hasNormalizedForm = raf.readBoolean();
normalizedToken = hasNormalizedForm ? raf.readUTF() : token;
if (index.dict.dictFileVersion >= 6) {
this.htmlEntries =
CachingList.create(
RAFList.create(raf, index.dict.htmlEntryIndexSerializer, raf.getFilePointer()), 1);
} else {
this.htmlEntries = Collections.emptyList();
}
}
Header(final RandomAccessFile raf) throws IOException {
byte[] bType = new byte[4];
raf.readFully(bType);
this.type = new String(bType, Charsets.US_ASCII);
if (!TYPE.equals(this.type)) {
throw new IOException("Invalid File Type " + this.type);
}
this.version = raf.readInt();
int metaDataSize = raf.readInt();
if (metaDataSize > 0) {
this.metaData = new byte[metaDataSize];
raf.readFully(this.metaData);
} else {
this.metaData = new byte[] {};
}
}
/**
* Parses the zip64 end of central directory record locator. The locator must be placed
* immediately before the end of central directory (eocd) record starting at {@code eocdOffset}.
*
* <p>The position of the file cursor for {@code raf} after a call to this method is undefined an
* callers must reposition it after each call to this method.
*/
public static long parseZip64EocdRecordLocator(RandomAccessFile raf, long eocdOffset)
throws IOException {
// The spec stays curiously silent about whether a zip file with an EOCD record,
// a zip64 locator and a zip64 eocd record is considered "empty". In our implementation,
// we parse all records and read the counts from them instead of drawing any size or
// layout based information.
if (eocdOffset > ZIP64_LOCATOR_SIZE) {
raf.seek(eocdOffset - ZIP64_LOCATOR_SIZE);
if (Integer.reverseBytes(raf.readInt()) == ZIP64_LOCATOR_SIGNATURE) {
byte[] zip64EocdLocator = new byte[ZIP64_LOCATOR_SIZE - 4];
raf.readFully(zip64EocdLocator);
ByteBuffer buf = ByteBuffer.wrap(zip64EocdLocator).order(ByteOrder.LITTLE_ENDIAN);
final int diskWithCentralDir = buf.getInt();
final long zip64EocdRecordOffset = buf.getLong();
final int numDisks = buf.getInt();
if (numDisks != 1 || diskWithCentralDir != 0) {
throw new ZipException("Spanned archives not supported");
}
return zip64EocdRecordOffset;
}
}
return -1;
}
public boolean hasNext() {
if (raf == null || !raf.getChannel().isOpen()) return false;
if (flagNext == true) return true; // Déjà lue
flagNext = true;
try {
next = new Entry();
next.timestamp = (long) raf.readInt();
next.value = raf.readFloat();
if (this.end != null && next.timestamp > this.end) {
next = null;
close();
return false;
}
return true;
} catch (IOException e) {
// EOF ou autre erreur d'IO
if (!(e instanceof EOFException)) logger.log(Level.WARNING, e.getMessage(), e);
next = null;
try {
close();
} catch (IOException e1) {
logger.log(Level.WARNING, e.getMessage(), e);
}
return false;
}
}
public Index(final Dictionary dict, final RandomAccessFile raf) throws IOException {
this.dict = dict;
shortName = raf.readUTF();
longName = raf.readUTF();
final String languageCode = raf.readUTF();
sortLanguage = Language.lookup(languageCode);
normalizerRules = raf.readUTF();
swapPairEntries = raf.readBoolean();
if (sortLanguage == null) {
throw new IOException("Unsupported language: " + languageCode);
}
if (dict.dictFileVersion >= 2) {
mainTokenCount = raf.readInt();
}
sortedIndexEntries =
CachingList.create(
RAFList.create(raf, indexEntrySerializer, raf.getFilePointer()), CACHE_SIZE);
if (dict.dictFileVersion >= 4) {
stoplist = new SerializableSerializer<Set<String>>().read(raf);
} else {
stoplist = Collections.emptySet();
}
rows =
CachingList.create(
UniformRAFList.create(raf, new RowBase.Serializer(this), raf.getFilePointer()),
CACHE_SIZE);
}
public List<Entry> getLastPoints(int nb) throws IOException {
File file = getFile();
RandomAccessFile raf = null;
List<Entry> result = null;
try {
raf = new RandomAccessFile(file, "r");
long pos = raf.length() - (nb * DATA_LEN);
if (pos < 0) {
nb = nb + (int) (pos / DATA_LEN);
pos = 0;
}
raf.seek(pos);
result = new ArrayList<Entry>(nb);
Entry next = null;
for (int i = 0; i < nb; i++) {
next = new Entry();
next.timestamp = (long) raf.readInt();
next.value = raf.readFloat();
result.add(0, next);
}
} finally {
if (raf != null) raf.close();
}
return result;
}
/*
* Creates new file in appropriate subFolder of respeakerApp.
* Returns true if file didn't exist before.
*/
private boolean setNewFileName(String filename) {
File dir = new File(TabConstants.PREFIX + subFolder);
dir.mkdirs();
// moving file out of inProgress folder if done respeaking
if (subFolder.equals("respeakings")) {
new File(filePath).renameTo(new File(dir, filename));
return true;
}
// otherwise create file object to check if it exists
File outputFile = new File(dir, filename);
try {
if (!outputFile.exists()) {
outputFile.createNewFile();
filePath = outputFile.getAbsolutePath();
fileSize = 0;
return true;
}
} catch (IOException e) {
Log.e("Microphone", "Error creating new file.");
}
filePath = outputFile.getAbsolutePath();
// if recording wasn't completed (i.e. respeaking was paused halfway), gets previous fileSize
try {
RandomAccessFile sizeWriter = new RandomAccessFile(outputFile, "rw");
sizeWriter.seek(40); // where size of raw data is located
if (fileSize == 0) fileSize = Integer.reverseBytes(sizeWriter.readInt());
sizeWriter.close();
Log.d("Microphone", "Filesize: " + Integer.toString(fileSize));
} catch (Exception e) {
Log.e("Microphone", "Error reading file size");
}
return false;
}
public int bubbleSort() throws Exception {
boolean swapped = true;
int j = 0;
int counter = 0;
while (swapped) {
swapped = false;
j++;
for (int i = 0; i < length() - j; i++) {
file.seek(i * 4);
int one = file.readInt();
int two = file.readInt();
if (one > two) {
file.seek(i * 4);
file.writeInt(two);
file.writeInt(one);
swapped = true;
counter++;
}
}
}
return counter;
}
@Override
public ITmfEvent parseEvent(final ITmfContext context) {
if (!(fEventStream instanceof TmfTraceStub)) {
return null;
}
// Highly inefficient...
final RandomAccessFile stream = ((TmfTraceStub) fEventStream).getStream();
if (stream == null) {
return null;
}
// String name = eventStream.getName();
// name = name.substring(name.lastIndexOf('/') + 1);
// no need to use synchronized since it's already cover by the calling method
long location = 0;
if (context != null && context.getLocation() != null) {
location = (Long) context.getLocation().getLocationInfo();
try {
stream.seek(location);
final long ts = stream.readLong();
stream.readUTF(); /* Previously source, now unused */
final String type = stream.readUTF();
stream.readInt(); /* Previously reference, now unused */
final int typeIndex = Integer.parseInt(type.substring(typePrefix.length()));
final String[] fields = new String[typeIndex];
for (int i = 0; i < typeIndex; i++) {
fields[i] = stream.readUTF();
}
final StringBuffer content = new StringBuffer("[");
if (typeIndex > 0) {
content.append(fields[0]);
}
for (int i = 1; i < typeIndex; i++) {
content.append(", ").append(fields[i]);
}
content.append("]");
final TmfEventField root =
new TmfEventField(ITmfEventField.ROOT_FIELD_ID, content.toString(), null);
final ITmfEvent event =
new TmfEvent(
fEventStream,
ITmfContext.UNKNOWN_RANK,
fEventStream.createTimestamp(ts * 1000000L),
fTypes[typeIndex],
root);
return event;
} catch (final EOFException e) {
} catch (final IOException e) {
}
}
return null;
}
/** {@inheritDoc} */
public int readInt() throws IOException {
fileSize -= 4;
if (fileSize < 0) {
throw new EOFException();
}
return dataInput.readInt();
}
private static void alterLastIFDOffset(RandomAccessFile rFile, int fileLen) throws IOException {
rFile.seek(0);
rFile.skipBytes(4);
int offsetIFD = rFile.readInt();
while (true) {
rFile.seek(offsetIFD);
int dirs = rFile.readShort();
rFile.skipBytes(dirs * 12);
offsetIFD = rFile.readInt();
if (offsetIFD == 0) {
int pointer = (int) rFile.getFilePointer();
rFile.seek(pointer - 4);
rFile.writeInt(fileLen);
break;
}
}
}
private static RegionFile fixNegativeOffset(File regionFileFile) {
FMLLog.log(
Level.WARNING,
"Region file " + regionFileFile + " is corrupted: negative offset. Attempting to fix.");
try {
Files.copy(
regionFileFile,
new File(regionFileFile.getParentFile(), regionFileFile.getName() + ".bak"));
} catch (IOException e) {
FMLLog.log(Level.SEVERE, e, "Failed to back up corrupt region file.");
}
try {
RandomAccessFile dataFile = new RandomAccessFile(regionFileFile, "rw");
try {
int length;
if (dataFile.length() < 4096L) {
for (length = 0; length < 1024; ++length) {
dataFile.writeInt(0);
}
for (length = 0; length < 1024; ++length) {
dataFile.writeInt(0);
}
}
if ((dataFile.length() & 4095L) != 0L) {
for (length = 0; (long) length < (dataFile.length() & 4095L); ++length) {
dataFile.write(0);
}
}
length = (int) dataFile.length() / 4096;
dataFile.seek(0L);
for (int i = 0; i < 1024; ++i) {
int offset = dataFile.readInt();
if (offset != 0 && (offset >> 8) + (offset & 255) <= length) {
for (int var5 = 0; var5 < (offset & 255); ++var5) {
if ((offset >> 8) + var5 < 0) {
dataFile.seek(dataFile.getFilePointer() - 4);
dataFile.writeInt(0);
break;
}
}
}
}
} finally {
dataFile.close();
}
} catch (Throwable t) {
FMLLog.log(Level.SEVERE, t, "Failed to fix negative offset index in " + regionFileFile);
throw UnsafeUtil.throwIgnoreChecked(t);
}
return new RegionFile(regionFileFile);
}
public void read() throws Exception {
file.seek(0);
System.out.print("[ ");
while (file.getFilePointer() < file.length()) System.out.print(file.readInt() + " ");
System.out.println("]");
}
SHeader(RandomAccessFile randomAccessFile) throws IOException {
this.nameidx = randomAccessFile.readInt();
this.type = randomAccessFile.readInt();
this.flags = randomAccessFile.readInt();
this.addr = randomAccessFile.readInt();
this.offset = randomAccessFile.readInt();
this.size = randomAccessFile.readInt();
this.link = randomAccessFile.readInt();
this.info = randomAccessFile.readInt();
this.addralign = randomAccessFile.readInt();
this.entsize = randomAccessFile.readInt();
this.elfInputStream = new ELFInputStream(randomAccessFile, offset, size);
}
private void loadDataXM(RandomAccessFile fp) throws IOException {
byte[] b = new byte[20];
// WHY THE HELL AM I DOING THIS
name = Util.readStringNoNul(fp, b, 20);
System.out.printf("name: \"%s\"\n", name);
fp.read(); // skip 0x1A byte
// THIS CAN'T BE HAPPENING
fp.read(b, 0, 20); // skip tracker name
// OH HELL NO
int xmver = 0xFFFF & (int) Short.reverseBytes(fp.readShort());
System.out.printf("XM version: %04X\n", xmver);
// WHAT IS THIS CRAP
InhibitedFileBlock ifb = new InhibitedFileBlock(fp, Integer.reverseBytes(fp.readInt()) - 4);
// HELP ME PLEASE
int ordnum = 0xFFFF & (int) Short.reverseBytes(ifb.readShort());
int respos =
0xFFFF & (int) Short.reverseBytes(ifb.readShort()); // can't be bothered right now --GM
int chnnum =
0xFFFF & (int) Short.reverseBytes(ifb.readShort()); // yeah sure, allow out of range values
if (chnnum > 64)
throw new RuntimeException(
String.format("%d-channel modules not supported (max 64)", chnnum));
int patnum = 0xFFFF & (int) Short.reverseBytes(ifb.readShort());
int insnum = 0xFFFF & (int) Short.reverseBytes(ifb.readShort());
int xmflags = 0xFFFF & (int) Short.reverseBytes(ifb.readShort());
int xmspeed = 0xFFFF & (int) Short.reverseBytes(ifb.readShort());
int xmtempo = 0xFFFF & (int) Short.reverseBytes(ifb.readShort());
// OH PLEASE, STOP IT
if (ordnum > 255) ordnum = 255;
if (xmtempo > 255) xmtempo = 255;
if (xmspeed > 255) xmspeed = 255;
this.bpm = xmtempo;
this.spd = xmspeed;
this.flags = FLAG_COMPATGXX | FLAG_OLDEFFECTS | FLAG_INSMODE | FLAG_STEREO | FLAG_VOL0MIX;
if ((xmflags & 0x01) != 0) this.flags |= FLAG_LINEAR;
// NONONONONONO
System.out.printf("chn=%d ordnum=%d tempo=%d speed=%s\n", chnnum, ordnum, xmtempo, xmspeed);
for (int i = 0; i < 256; i++) orderlist[i] = ifb.read();
for (int i = ordnum; i < 256; i++) orderlist[i] = 255;
ifb.done();
// SAVE ME PLEEEEEAAASSSSEEEE
for (int i = 0; i < patnum; i++)
map_pat.put((Integer) i, new SessionPattern(this, fp, SessionPattern.FORMAT_XM, chnnum));
for (int i = 0; i < insnum; i++)
map_ins.put((Integer) (i + 1), new SessionInstrument(fp, SessionInstrument.FORMAT_XM, this));
}
public final int readInt() throws IOException {
int i = mRaf.readInt();
if (mIsLittleEndian) {
return ((i & 0x000000ff) << 24)
| ((i & 0x0000ff00) << 8)
| ((i & 0x00ff0000) >>> 8)
| ((i & 0xff000000) >>> 24);
}
return i;
}
/*
* gets an (uncompressed) stream representing the chunk data returns null if
* the chunk is not found or an error occurs
*/
public synchronized DataInputStream getChunkDataInputStream(int x, int z) {
if (outOfBounds(x, z)) {
debugln("READ", x, z, "out of bounds");
return null;
}
try {
int offset = getOffset(x, z);
if (offset == 0) {
// debugln("READ", x, z, "miss");
return null;
}
int sectorNumber = offset >> 8;
int numSectors = offset & 0xFF;
if (sectorNumber + numSectors > sectorFree.size()) {
debugln("READ", x, z, "invalid sector");
return null;
}
file.seek(sectorNumber * SECTOR_BYTES);
int length = file.readInt();
if (length > SECTOR_BYTES * numSectors) {
debugln("READ", x, z, "invalid length: " + length + " > 4096 * " + numSectors);
return null;
}
byte version = file.readByte();
if (version == VERSION_GZIP) {
byte[] data = new byte[length - 1];
file.read(data);
DataInputStream ret =
new DataInputStream(
new BufferedInputStream(new GZIPInputStream(new ByteArrayInputStream(data))));
// debug("READ", x, z, " = found");
return ret;
} else if (version == VERSION_DEFLATE) {
byte[] data = new byte[length - 1];
file.read(data);
DataInputStream ret =
new DataInputStream(
new BufferedInputStream(new InflaterInputStream(new ByteArrayInputStream(data))));
// debug("READ", x, z, " = found");
return ret;
}
debugln("READ", x, z, "unknown version " + version);
return null;
} catch (IOException e) {
debugln("READ", x, z, "exception");
return null;
}
}
public static ZipFile.EocdRecord parseZip64EocdRecord(
RandomAccessFile raf, long eocdRecordOffset, int commentLength) throws IOException {
raf.seek(eocdRecordOffset);
final int signature = Integer.reverseBytes(raf.readInt());
if (signature != ZIP64_EOCD_RECORD_SIGNATURE) {
throw new ZipException(
"Invalid zip64 eocd record offset, sig="
+ Integer.toHexString(signature)
+ " offset="
+ eocdRecordOffset);
}
// The zip64 eocd record specifies its own size as an 8 byte integral type. It is variable
// length because of the "zip64 extensible data sector" but that field is reserved for
// pkware's proprietary use. We therefore disregard it altogether and treat the end of
// central directory structure as fixed length.
//
// We also skip "version made by" (2 bytes) and "version needed to extract" (2 bytes)
// fields. We perform additional validation at the ZipEntry level, where applicable.
//
// That's a total of 12 bytes to skip
raf.skipBytes(12);
byte[] zip64Eocd = new byte[ZIP64_EOCD_RECORD_EFFECTIVE_SIZE];
raf.readFully(zip64Eocd);
ByteBuffer buf = ByteBuffer.wrap(zip64Eocd).order(ByteOrder.LITTLE_ENDIAN);
try {
int diskNumber = buf.getInt();
int diskWithCentralDirStart = buf.getInt();
long numEntries = buf.getLong();
long totalNumEntries = buf.getLong();
buf.getLong(); // Ignore the size of the central directory
long centralDirOffset = buf.getLong();
if (numEntries != totalNumEntries || diskNumber != 0 || diskWithCentralDirStart != 0) {
throw new ZipException(
"Spanned archives not supported :"
+ " numEntries="
+ numEntries
+ ", totalNumEntries="
+ totalNumEntries
+ ", diskNumber="
+ diskNumber
+ ", diskWithCentralDirStart="
+ diskWithCentralDirStart);
}
return new ZipFile.EocdRecord(numEntries, centralDirOffset, commentLength);
} catch (BufferUnderflowException bue) {
ZipException zipException = new ZipException("Error parsing zip64 eocd record.");
zipException.initCause(bue);
throw zipException;
}
}
private String readFromDataBase(final RandomAccessFile dbFile) throws MapExcept {
try {
int wordlen = dbFile.readInt();
byte[] word = new byte[wordlen];
dbFile.read(word, 0, wordlen);
return new String(word);
} catch (IOException e) {
throw new MapExcept("Can't read from database");
}
}
public static void main(String args[]) {
try {
String fname = "d:\\q.txt";
String mode;
// mode = "r";//r : file must exist
mode = "rw"; // rw : file will be created or opened
// open the file
RandomAccessFile raf = new RandomAccessFile(fname, mode);
/*
//seek and write demo
raf.seek(10);//position file r/w pointer at index 10 wrt BOF
//a seek beyond file size causes file to grow upto the seek value
raf.write(65);//raf.write('A');
*/
// r/w java datatypes
int i1, i2;
float f1, f2;
char c1, c2;
String s1, s2;
i1 = -10;
f1 = 1234.5678F;
c1 = 'q';
s1 = "hello files";
raf.seek(0); // reach BOF
raf.writeInt(i1);
raf.writeFloat(f1);
raf.writeChar(c1);
raf.writeUTF(s1);
raf.seek(0); // reach BOF
i2 = raf.readInt();
f2 = raf.readFloat();
c2 = raf.readChar();
s2 = raf.readUTF();
System.out.println(i2);
System.out.println(f2);
System.out.println(c2);
System.out.println(s2);
// close the file
raf.close();
} catch (IOException ex) {
System.out.println(ex); // ex converts into ex.toString()
}
} // main
public static void main(String[] args) throws IOException {
try ( // Create a random access file
RandomAccessFile inout = new RandomAccessFile("inout.dat", "rw"); ) {
// Clear the file to destroy the old contents if exists
inout.setLength(0);
// Write new integers to the file
for (int i = 0; i < 200; i++) inout.writeInt(i);
// Display the current length of the file
System.out.println("Current file length is " + inout.length());
// Retrieve the first number
inout.seek(0); // Move the file pointer to the beginning
System.out.println("The first number is " + inout.readInt());
// Retrieve the second number
inout.seek(1 * 4); // Move the file pointer to the second number
System.out.println("The second number is " + inout.readInt());
// Retrieve the tenth number
inout.seek(9 * 4); // Move the file pointer to the tenth number
System.out.println("The tenth number is " + inout.readInt());
// Modify the eleventh number
inout.writeInt(555);
// Append a new number
inout.seek(inout.length()); // Move the file pointer to the end
inout.writeInt(999);
// Display the new length
System.out.println("The new length is " + inout.length());
// Retrieve the new eleventh number
inout.seek(10 * 4); // Move the file pointer to the eleventh number
System.out.println("The eleventh number is " + inout.readInt());
}
}
public RecordRange seek(String pattern, int size) {
RandomAccessFile currentFile = file[size - 1];
long pos, mid, head, tail;
short strLen;
byte buf[] = new byte[strSize];
try {
head = 0;
tail = currentFile.length() / recLen - 1;
while (head <= tail) {
mid = (head + tail) / 2;
pos = mid * recLen;
currentFile.seek(pos);
strLen = currentFile.readShort();
currentFile.read(buf, 0, strLen);
String str = new String(buf, 0, strLen);
int cmp = pattern.compareTo(str);
if (cmp < 0) tail = mid - 1;
else if (cmp > 0) head = mid + 1;
else {
currentFile.seek(pos + lenSize + strSize);
int spageID = currentFile.readInt();
int soffset = currentFile.readInt();
int epageID = currentFile.readInt();
int eoffset = currentFile.readInt();
return new RecordRange(new RID(spageID, soffset), new RID(epageID, eoffset));
}
}
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
private void update() throws DatabaseCorruptedException, IOException {
try (RandomAccessFile file = new RandomAccessFile(filePath.toString(), "r")) {
if (file.length() == 0) {
throw new DatabaseCorruptedException("Data base corrupted: empty file found");
}
List<String> keys = new LinkedList<>();
List<Integer> offsets = new LinkedList<>();
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
byte b;
int counter = 0;
do { // Read keys.
while ((b = file.readByte()) != 0) {
counter++;
bytes.write(b);
}
++counter;
offsets.add(file.readInt());
counter += 4;
String key = bytes.toString(TableManager.CODE_FORMAT);
bytes.reset();
if (!checkKey(key)) {
throw new DatabaseCorruptedException("Wrong key found in file " + filePath.toString());
}
keys.add(key);
} while (counter < offsets.get(0));
offsets.add((int) file.length());
offsets.remove(0); // It's current position in file, we don't need it in list.
Iterator<String> keyIterator = keys.iterator();
for (int nextOffset : offsets) { // Read values.
while (counter < nextOffset) {
bytes.write(file.readByte());
counter++;
}
if (bytes.size() > 0) {
try {
fileMap.put(
keyIterator.next(),
provider.deserialize(table, bytes.toString(TableManager.CODE_FORMAT)));
} catch (ParseException e) {
throw new RuntimeException(
"Data corrupted in file " + filePath.toString() + " : " + e.getMessage());
}
bytes.reset();
} else {
throw new DatabaseCorruptedException("Data corrupted in file " + filePath.toString());
}
}
bytes.close();
}
}
/* Package visible for testing */
static CentralDirectory findCentralDirectory(RandomAccessFile raf)
throws IOException, ZipException {
long scanOffset = raf.length() - ENDHDR;
if (scanOffset < 0) {
throw new ZipException("File too short to be a zip file: " + raf.length());
}
long stopOffset = scanOffset - 0x10000 /* ".ZIP file comment"'s max length */;
if (stopOffset < 0) {
stopOffset = 0;
}
int endSig = Integer.reverseBytes(ENDSIG);
while (true) {
raf.seek(scanOffset);
if (raf.readInt() == endSig) {
break;
}
scanOffset--;
if (scanOffset < stopOffset) {
throw new ZipException("End Of Central Directory signature not found");
}
}
// Read the End Of Central Directory. ENDHDR includes the signature
// bytes,
// which we've already read.
// Pull out the information we need.
raf.skipBytes(2); // diskNumber
raf.skipBytes(2); // diskWithCentralDir
raf.skipBytes(2); // numEntries
raf.skipBytes(2); // totalNumEntries
CentralDirectory dir = new CentralDirectory();
dir.size = Integer.reverseBytes(raf.readInt()) & 0xFFFFFFFFL;
dir.offset = Integer.reverseBytes(raf.readInt()) & 0xFFFFFFFFL;
return dir;
}
protected long readHeader(RandomAccessFile raFile) throws IOException {
raFile.seek(0);
if (raFile.length() == 0) return -1;
String versionHint = raFile.readUTF();
if (!"GH".equals(versionHint))
throw new IllegalArgumentException(
"Not a GraphHopper file! Expected 'GH' as file marker but was " + versionHint);
// use a separate version field
int majorVersion = raFile.readInt();
if (majorVersion != version())
throw new IllegalArgumentException(
"This GraphHopper file has the wrong version! "
+ "Expected "
+ version()
+ " but was "
+ majorVersion);
long bytes = raFile.readLong();
segmentSize(raFile.readInt());
for (int i = 0; i < header.length; i++) {
header[i] = raFile.readInt();
}
return bytes;
}
private NameFileIdEntry readNextNameIdEntry() throws IOException {
try {
final int nameSize = nameIdMapHolder.readInt();
byte[] serializedName = new byte[nameSize];
nameIdMapHolder.readFully(serializedName);
final String name = OStringSerializer.INSTANCE.deserialize(serializedName, 0);
final long fileId = nameIdMapHolder.readLong();
return new NameFileIdEntry(name, fileId);
} catch (EOFException eof) {
return null;
}
}