private static void parseData() throws IOException { TreeSet<String> fs = scanPath(); parseMeta(); if (fs.size() == 0) return; String absolutePath = new File(fs.first()).getCanonicalPath(); String absolutePath2 = new File(name).getCanonicalPath(); if (!absolutePath.equals(absolutePath2)) { System.out.println("meta file name not match first file, use first file"); pos = 0; } for (String filename : fs) { RandomAccessFile f = new RandomAccessFile(filename, "r"); MappedByteBuffer map = f.getChannel().map(MapMode.READ_ONLY, 0, f.length()); map.position((int) pos); while (map.hasRemaining()) { int size = map.getInt(); byte[] c = new byte[size]; map.get(c); Message m = MessageFactory.getInstance().createMessageFrom(c); m.decompress(); System.out.println("get content: " + asString(m)); } map.clear(); map = null; f.close(); pos = 0; } }
/** * Seek for box with the specified id starting from the current location of filepointer, * * <p>Note it wont find the box if it is contained with a level below the current level, nor if we * are at a parent atom that also contains data and we havent yet processed the data. It will work * if we are at the start of a child box even if it not the required box as long as the box we are * looking for is the same level (or the level above in some cases). * * @param raf * @param id * @throws java.io.IOException */ public static Mp4BoxHeader seekWithinLevel(RandomAccessFile raf, String id) throws IOException { logger.finer("Started searching for:" + id + " in file at:" + raf.getChannel().position()); Mp4BoxHeader boxHeader = new Mp4BoxHeader(); ByteBuffer headerBuffer = ByteBuffer.allocate(HEADER_LENGTH); int bytesRead = raf.getChannel().read(headerBuffer); if (bytesRead != HEADER_LENGTH) { return null; } headerBuffer.rewind(); boxHeader.update(headerBuffer); while (!boxHeader.getId().equals(id)) { logger.finer("Still searching for:" + id + " in file at:" + raf.getChannel().position()); // Something gone wrong probably not at the start of an atom so return null; if (boxHeader.getLength() < Mp4BoxHeader.HEADER_LENGTH) { return null; } int noOfBytesSkipped = raf.skipBytes(boxHeader.getDataLength()); logger.finer("Skipped:" + noOfBytesSkipped); if (noOfBytesSkipped < boxHeader.getDataLength()) { return null; } headerBuffer.rewind(); bytesRead = raf.getChannel().read(headerBuffer); logger.finer("Header Bytes Read:" + bytesRead); headerBuffer.rewind(); if (bytesRead == Mp4BoxHeader.HEADER_LENGTH) { boxHeader.update(headerBuffer); } else { return null; } } return boxHeader; }
public void loadMetaData() throws IOException { pageFile.seek(offset); nextPageId = pageFile.readInt(); currentFill = pageFile.readInt(); bloomfilter = pageFile.readInt(); type = pageFile.readByte(); }
public static String readString(RandomAccessFile f, long l) throws IOException { f.seek(l - 1); int length = (int) f.readUnsignedByte(); byte[] strArr = new byte[length]; f.read(strArr); return new String(strArr); }
/** * Sets the version for the given neostore file in {@code storeDir}. * * @param storeDir the store dir to locate the neostore file in. * @param version the version to set. * @return the previous version before writing. */ public static long setVersion(String storeDir, long version) { RandomAccessFile file = null; try { file = new RandomAccessFile(new File(storeDir, NeoStore.DEFAULT_NAME), "rw"); FileChannel channel = file.getChannel(); channel.position(RECORD_SIZE * 2 + 1 /*inUse*/); ByteBuffer buffer = ByteBuffer.allocate(8); channel.read(buffer); buffer.flip(); long previous = buffer.getLong(); channel.position(RECORD_SIZE * 2 + 1 /*inUse*/); buffer.clear(); buffer.putLong(version).flip(); channel.write(buffer); return previous; } catch (IOException e) { throw new RuntimeException(e); } finally { try { if (file != null) file.close(); } catch (IOException e) { throw new RuntimeException(e); } } }
/** * @param filePath * @param seek * @param length * @return */ public static byte[] readFlieToByte(String filePath, int seek, int length) { if (TextUtils.isEmpty(filePath)) { return null; } File file = new File(filePath); if (!file.exists()) { return null; } if (length == -1) { length = (int) file.length(); } try { RandomAccessFile randomAccessFile = new RandomAccessFile(file, "r"); byte[] bs = new byte[length]; randomAccessFile.seek(seek); randomAccessFile.readFully(bs); randomAccessFile.close(); return bs; } catch (Exception e) { e.printStackTrace(); LogUtil.e( LogUtil.getLogUtilsTag(FileUtils.class), "readFromFile : errMsg = " + e.getMessage()); return null; } }
public String getValueFromFile(long nextOffset, RandomAccessFile dataFile) throws IOException { int beginPtr = (int) dataFile.getFilePointer(); byte[] res = new byte[(int) (nextOffset - beginPtr)]; dataFile.read(res); String result = new String(res, StandardCharsets.UTF_8); return result; }
private String readLine() throws IOException { StringBuffer sb = new StringBuffer(); char readChar; int ch; long pos = reader.getFilePointer(); long length = file.length(); if ((length < pos) || (length == pos && FileUtils.isFileNewer(file, accessTime))) { // file got rotated or truncated reader.close(); reader = new RandomAccessFile(file, "r"); position = 0; reader.seek(position); pos = 0; } accessTime = System.currentTimeMillis(); while ((ch = reader.read()) != -1) { readChar = (char) ch; if (readChar != delimiter) { sb.append(readChar); } else { return sb.toString(); } } reader.seek(pos); return null; }
private int readBytes(Entry entry, byte[] buffer) throws IOException { byte[] header = getHeader(entry); // entry is not compressed? if (get2ByteLittleEndian(header, 8) == 0) { zipRandomFile.skipBytes(get2ByteLittleEndian(header, 26) + get2ByteLittleEndian(header, 28)); int offset = 0; int size = buffer.length; while (offset < size) { int count = zipRandomFile.read(buffer, offset, size - offset); if (count == -1) break; offset += count; } return entry.size; } int csize = entry.compressedSize; byte[] cbuf = new byte[csize]; zipRandomFile.skipBytes(get2ByteLittleEndian(header, 26) + get2ByteLittleEndian(header, 28)); zipRandomFile.readFully(cbuf, 0, csize); int count = inflate(cbuf, buffer); if (count == -1) throw new ZipException("corrupted zip file"); return entry.size; }
public void newCheckpoint(byte[] state, byte[] stateHash, int consensusId) { String ckpPath = DEFAULT_DIR + String.valueOf(id) + "." + System.currentTimeMillis() + ".tmp"; try { checkpointLock.lock(); RandomAccessFile ckp = new RandomAccessFile(ckpPath, (syncCkp ? "rwd" : "rw")); ByteBuffer bf = ByteBuffer.allocate(state.length + stateHash.length + 4 * INT_BYTE_SIZE); bf.putInt(state.length); bf.put(state); bf.putInt(stateHash.length); bf.put(stateHash); bf.putInt(EOF); bf.putInt(consensusId); byte[] ckpState = bf.array(); ckp.write(ckpState); ckp.close(); if (isToLog) deleteLogFile(); deleteLastCkp(); renameCkp(ckpPath); if (isToLog) createLogFile(); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } finally { checkpointLock.unlock(); } }
void corruptFile(int position) throws Exception { File file = new File(getDirectory(), "transaction.log"); RandomAccessFile ra = new RandomAccessFile(file, "rw"); ra.seek(position); ra.write(0xff); ra.close(); }
private void addDescriptions() throws IOException { RandomAccessFile f = new RandomAccessFile("randomDescription.csv", "r"); String dataString = null; Random random = new Random(1l); ArrayList<String> descriptions = new ArrayList<String>(); while ((dataString = f.readLine()) != null) { descriptions.add(dataString); } f.close(); try { ArrayList<Resource> resources = resourceDAO.getAllResources(); for (Resource r : resources) { r.setDescription(descriptions.get(random.nextInt(descriptions.size()))); resourceDAO.updateResource(r); } } catch (DAOException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (ResourceNameExistsException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (ResourceHasActiveProjectException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
private void addResources() throws IOException { RandomAccessFile f = new RandomAccessFile("randomResource.csv", "r"); String dataString = null; ResourceType type = null; while ((dataString = f.readLine()) != null) { String[] data = dataString.split(";"); Resource insert = new Resource(); if (data[0].length() < 45) { insert.setResourceName(data[0]); } else { insert.setResourceName(data[0].substring(0, 44)); } try { insert.setResourceTypeID( resourceTypeDAO.getResourceTypeByResourceTypeName(data[1]).getResourceTypeID()); } catch (Exception e1) { e1.printStackTrace(); } insert.setDescription(""); insert.setActive(true); System.out.println(insert); try { resourceDAO.insertResource(insert); } catch (Exception e) { e.printStackTrace(); } } f.close(); }
@Override public void run() { try { URL url = new URL(path); HttpURLConnection conn = (HttpURLConnection) url.openConnection(); conn.setConnectTimeout(5 * 1000); conn.setRequestMethod("GET"); conn.setRequestProperty( "Accept", "image/gif, image/jpeg, image/pjpeg, image/pjpeg, " + "application/x-shockwave-flash, application/xaml+xml, " + "application/vnd.ms-xpsdocument, application/x-ms-xbap, " + "application/x-ms-application, application/vnd.ms-excel, " + "application/vnd.ms-powerpoint, application/msword, */*"); conn.setRequestProperty("Accept-Language", "zh-CN"); conn.setRequestProperty("Charset", "UTF-8"); conn.setRequestProperty("Connection", "Keep-Alive"); InputStream inputStream = conn.getInputStream(); // 跳过startPos那一部分内容,表明该线程仅下载属于它自己的那一部分 inputStream.skip(this.startPos); byte[] bytes = new byte[1024]; int hasRead = 0; while (length < currentPartSize && (hasRead = inputStream.read(bytes)) != -1) { currentPart.write(bytes, 0, hasRead); length += hasRead; } currentPart.close(); inputStream.close(); } catch (Exception e) { e.printStackTrace(); } }
/** * Reads data from the given file into the given buffer, centered around the given file offset. * The first half of the buffer will be filled with data right before the given offset, while the * remainder of the buffer will contain data right after it (of course, containing the byte at the * given offset). * * @param stream The stream to read from * @param buffer The buffer to read data into * @param fileReferenceOffset The offset to start reading from in the stream. * @return The number of bytes reads, which could be less than the length of the input buffer if * we can't read due to the beginning or the end of the file. * @throws IOException Thrown if the stream being used is invalid or inaccessible. */ private static int readIntoBufferAroundReference( RandomAccessFile stream, byte[] buffer, long fileReferenceOffset) throws IOException { int length = buffer.length; // calculate start offset long fileStartOffset = fileReferenceOffset - length / 2; if (fileStartOffset < 0) { // offset is less than zero, adjust it, as well as the length we want to read length += (int) fileStartOffset; fileStartOffset = 0; if (length <= 0) { return 0; } } if (fileStartOffset + length > stream.length()) { // startOffset + length is beyond the end of the stream, adjust the length accordingly length = (int) (stream.length() - fileStartOffset); if (length <= 0) { return 0; } } // read the appropriate block of the file into the buffer, using symmetry with respect to its // midpoint // we always initiate a seek from the origin of the file. stream.seek(0); stream.seek(fileStartOffset); int bufferOffset = 0; while (bufferOffset < length) { int bytesRead = stream.read(buffer, bufferOffset, length - bufferOffset); bufferOffset += bytesRead; } return length; }
/** Creates new CoverageFormat1 */ protected CoverageFormat1(RandomAccessFile raf) throws IOException { glyphCount = raf.readUnsignedShort(); glyphIds = new int[glyphCount]; for (int i = 0; i < glyphCount; i++) { glyphIds[i] = raf.readUnsignedShort(); } }
protected ChannelFuture sendFile(File file) { final RandomAccessFile raf; try { raf = new RandomAccessFile(file, "r"); long fileLength = file.length(); // Write the content. ChannelFuture writeFuture; if (isSSL()) { // Cannot use zero-copy with HTTPS. writeFuture = channel.write(new ChunkedFile(raf, 0, fileLength, 8192)); } else { // No encryption - use zero-copy. final FileRegion region = new DefaultFileRegion(raf.getChannel(), 0, fileLength); writeFuture = channel.write(region); } writeFuture.addListener( new ChannelFutureListener() { public void operationComplete(ChannelFuture future) throws Exception { raf.close(); } }); return writeFuture; } catch (IOException e) { handleException(e); return null; } }
private final void testVerifyUnversioned(String subDir) throws Exception { UnversionedVerifier verifier = new UnversionedVerifier(testData(subDir)); RandomAccessFile activeInput = new RandomAccessFile(testData(subDir) + "/2.unversioned", "r"); String activeSignature = activeInput.readLine(); activeInput.close(); assertTrue(verifier.verify(input, activeSignature)); }
@Override protected void parseBody(final RandomAccessFile mpegFile) throws IOException { final int size = (int) (super.seekToBodyStart(mpegFile) - 4); mpegFile.skipBytes(4); // Reserved rawBytes = new byte[size]; mpegFile.readFully(rawBytes); }
@SuppressWarnings({"unchecked"}) void initializeFS() { try { JSONObject obj = new JSONObject(); JSONArray jar = new JSONArray(); jar.add("0 1#1"); obj.put("version", jar); obj.put("lastblock", "1"); version = 0; file.write(obj.toJSONString().getBytes()); superBlock = new SuperBlock(obj.toJSONString().getBytes()); // Done super block lastblock = 1; file.seek(1024); // root direc JSONObject obj1 = new JSONObject(); JSONArray ch_dir = new JSONArray(); obj1.put("dir", ch_dir); file.write(obj1.toJSONString().getBytes()); file.close(); getFile(); superBlock.loadDMap(version, file); } catch (IOException | ParseException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
private void getAgentIcons() { try { RandomAccessFile participantsFile = new RandomAccessFile( Simulator.inputFoldersPath + Simulator.inputFolder + "/participants.csv", "r"); participantsFile.readLine(); String currentLine = participantsFile.readLine(); // Set the System Data while (!(currentLine == null)) { String[] theArgs = StringParseTools.readTokens(currentLine, ","); if (theArgs[2].contains("<player>")) { try { agentIcons.put(theArgs[1], convert(ImageIO.read(new File("images/" + theArgs[3])))); } catch (Exception e) { logger.warn( "Couldn't find the icon file 'images/" + theArgs[3] + "' for agent '" + theArgs[1] + "'."); } } // get next line currentLine = participantsFile.readLine(); } participantsFile.close(); } catch (Exception e) { logger.fatal("Error access System I/O file: ", e); } }
private void execFormatTrackTask() { File file = this.ioFile; long pos = this.ioFilePos; int cnt = this.ioByteCnt; if ((file != null) && (pos >= 0) && (cnt > 0)) { boolean err = false; RandomAccessFile raf = null; try { raf = new RandomAccessFile(file, "rw"); raf.seek(pos); while (cnt > 0) { raf.write(0); --cnt; } raf.close(); raf = null; } catch (IOException ex) { err = true; if (!this.writeErrShown) { this.writeErrShown = true; EmuUtil.fireShowError(this.owner, null, ex); } } finally { EmuUtil.doClose(raf); } if (err) { this.errorReg = ERROR_UNCORRECTABLE_DATA; this.statusReg |= STATUS_ERROR; } fireInterrupt(); } }
@Override public void run() { try { while (shouldIRun) { Thread.sleep(crunchifyRunEveryNSeconds); long fileLength = crunchifyFile.length(); if (fileLength > lastKnownPosition) { // Reading and writing file RandomAccessFile readWriteFileAccess = new RandomAccessFile(crunchifyFile, "rw"); readWriteFileAccess.seek(lastKnownPosition); String crunchifyLine = null; while ((crunchifyLine = readWriteFileAccess.readLine()) != null) { for (Session s : AppLogView.sessions) { // s.getAsyncRemote().sendText(crunchifyLine); s.getBasicRemote().sendText(crunchifyLine); } } lastKnownPosition = readWriteFileAccess.getFilePointer(); readWriteFileAccess.close(); } } } catch (Exception e) { shouldIRun = false; } }
/** @return A {@link Yes1Reader}, {@link Yes2Reader}, or null if there is any error. */ public static BibleReader createYesReader(String filename) { try { RandomAccessFile f = new RandomAccessFile(filename, "r"); byte[] header = new byte[8]; f.read(header); if (header[0] != (byte) 0x98 || header[1] != (byte) 0x58 || header[2] != (byte) 0x0d || header[3] != (byte) 0x0a || header[4] != (byte) 0x00 || header[5] != (byte) 0x5d || header[6] != (byte) 0xe0) { Log.e(TAG, "Yes file has not a correct header. Header is: " + Arrays.toString(header)); return null; } if (header[7] == 0x01) { // VERSION 1 YES return new Yes1Reader(f); } else if (header[7] == 0x02) { // VERSION 2 YES return new Yes2Reader(new RandomAccessFileRandomInputStream(f)); } else { Log.e(TAG, "Yes file version unsupported: " + header[7]); return null; } } catch (IOException e) { Log.e(TAG, "@@createYesReader io exception", e); return null; } }
private static long getRecord(String storeDir, long recordPosition) { RandomAccessFile file = null; try { file = new RandomAccessFile(new File(storeDir), "rw"); FileChannel channel = file.getChannel(); /* * We have to check size, because the store version * field was introduced with 1.5, so if there is a non-clean * shutdown we may have a buffer underflow. */ if (recordPosition > 3 && channel.size() < RECORD_SIZE * 5) { return -1; } channel.position(RECORD_SIZE * recordPosition + 1 /*inUse*/); ByteBuffer buffer = ByteBuffer.allocate(8); channel.read(buffer); buffer.flip(); long previous = buffer.getLong(); return previous; } catch (IOException e) { throw new RuntimeException(e); } finally { try { if (file != null) file.close(); } catch (IOException e) { throw new RuntimeException(e); } } }
private String readInstallationFileBad(File installation) throws IOException { RandomAccessFile f = new RandomAccessFile(installation, "r"); byte[] bytes = new byte[(int) f.length()]; f.readFully(bytes); f.close(); return new String(bytes); }
public void saveMetaData() throws IOException { pageFile.seek(offset); pageFile.writeInt(nextPageId); pageFile.writeInt(currentFill); pageFile.writeInt(bloomfilter); pageFile.writeByte(type); }
public int luaCB_read(Lua l, LuaPlugin plugin) { l.pushNil(); l.pushNil(); try { long offset = (long) l.checkNumber(2); int length = (int) l.checkNumber(3); if (length <= 0) { l.pushNil(); l.pushString("Length is not positive"); return 2; } byte[] tmp = new byte[length]; object.seek(offset); length = object.read(tmp); if (length < 0) { l.pushNil(); l.pushNil(); return 2; } StringBuffer buf = new StringBuffer(length); for (byte x : tmp) buf.appendCodePoint((int) x & 0xFF); l.push(buf.toString()); } catch (IOException e) { l.pushNil(); l.pushString("IOException: " + e.getMessage()); return 2; } return 1; }
/** * 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; }
private CsvFile(File csv, CoordinateReferenceSystem crs) throws IOException { this.csv = csv; ConverterRegistry.getInstance().setConverter(ProductData.UTC.class, new UTCConverter()); this.crs = crs; RandomAccessFile randomAccessFile = new RandomAccessFile(csv, "r"); stream = new FileChannelImageInputStream(randomAccessFile.getChannel()); }