@Transactional public void load(String gtfsUrl) throws IOException { File file = openGtfsFile(gtfsUrl); cleanDB(); ZipInputStream stream = new ZipInputStream(new FileInputStream(file)); try { BufferedReader reader = new BufferedReader(new InputStreamReader(stream)); write("Routes..."); getEntry(stream, "routes.txt"); parseRoutes(reader); write("Stops..."); getEntry(stream, "stops.txt"); parseStops(reader); write("Trips..."); getEntry(stream, "trips.txt"); parseTrips(reader); write("Stop Times..."); getEntry(stream, "stop_times.txt"); parseStopTimes(reader); write("Finialising..."); } catch (Exception e) { write(e + ": " + e.getMessage()); } finally { Route.entityManager().flush(); stream.close(); write("Done."); } }
/** * Unzips entries from {@code stream} into {@code directory}. * * @param stream source zip stream * @param directory target directory to which entries going to be unzipped. * @param buffer the buffer to use * @throws IOException if an I/O error occurs. */ public static void unzip(final ZipInputStream stream, final File directory, final byte[] buffer) throws IOException { if (stream == null) { throw new NullPointerException("stream"); } if (directory == null) { throw new NullPointerException("directory"); } if (!directory.isDirectory()) { throw new IllegalArgumentException("directory doesn't exist"); } if (buffer == null) { throw new NullPointerException("buffer"); } if (buffer.length == 0) { throw new IllegalArgumentException("buffer.length(" + buffer.length + ") == 0"); } ZipEntry entry; while ((entry = stream.getNextEntry()) != null) { final File file = file(directory, entry); if (!entry.isDirectory()) { ByteStreams.copy(stream, file, buffer, -1L); } stream.closeEntry(); } }
/** * The URLs are a bit ugly and so we need to find out which area name a certain lat,lon coordinate * has. */ private SRTMProvider init() { try { String strs[] = { "Africa", "Australia", "Eurasia", "Islands", "North_America", "South_America" }; for (String str : strs) { InputStream is = getClass().getResourceAsStream(str + "_names.txt.zip"); ZipInputStream zis = new ZipInputStream(is); zis.getNextEntry(); for (String line : Helper.readFile(new InputStreamReader(zis, "UTF-8"))) { int lat = Integer.parseInt(line.substring(1, 3)); if (line.substring(0, 1).charAt(0) == 'S') lat = -lat; int lon = Integer.parseInt(line.substring(4, 7)); if (line.substring(3, 4).charAt(0) == 'W') lon = -lon; int intKey = calcIntKey(lat, lon); String key = areas.put(intKey, str); if (key != null) throw new IllegalStateException( "do not overwrite existing! key " + intKey + " " + key + " vs. " + str); } } return this; } catch (Exception ex) { throw new IllegalStateException("Cannot load area names from classpath", ex); } }
/** * Unzip given file into given folder. * * @param fileZip : zip file to unzip. * @param dirOut : folder where to put the unzipped files. */ public static void unzip(File fileZip, File dirOut) { try { byte[] buf = new byte[10 * 1024]; if (!fileZip.canRead()) throw new IllegalArgumentException(fileZip.getAbsolutePath()); if (!dirOut.isDirectory()) dirOut.mkdirs(); if (!dirOut.isDirectory()) throw new IllegalArgumentException(dirOut.getAbsolutePath()); FileInputStream fin = new FileInputStream(fileZip); ZipInputStream zin = new ZipInputStream(fin); ZipEntry ze = null; while ((ze = zin.getNextEntry()) != null) { File fileZe = new File(dirOut, ze.getName()); Log.i("Zip", fileZe.getAbsolutePath()); if (ze.isDirectory()) continue; assureParentExists(fileZe); BufferedOutputStream fout = new BufferedOutputStream(new FileOutputStream(fileZe)); while (true) { int read = zin.read(buf); if (-1 == read) break; // End of file. fout.write(buf, 0, read); } zin.closeEntry(); fout.close(); } zin.close(); } catch (Exception e) { Log.e("MyZip", "unzip", e); } }
/* @see loci.formats.FormatReader#initFile(String) */ protected void initFile(String id) throws FormatException, IOException { super.initFile(id); reader = new ImageReader(); reader.setMetadataOptions(getMetadataOptions()); reader.setMetadataFiltered(isMetadataFiltered()); reader.setOriginalMetadataPopulated(isOriginalMetadataPopulated()); reader.setNormalized(isNormalized()); reader.setMetadataStore(getMetadataStore()); // NB: We need a raw handle on the ZIP data itself, not a ZipHandle. IRandomAccess rawHandle = Location.getHandle(id, false, false); in = new RandomAccessInputStream(rawHandle, id); ZipInputStream zip = new ZipInputStream(in); while (true) { ZipEntry ze = zip.getNextEntry(); if (ze == null) break; ZipHandle handle = new ZipHandle(id, ze); Location.mapFile(ze.getName(), handle); mappedFiles.add(ze.getName()); } ZipHandle base = new ZipHandle(id); reader.setId(base.getEntryName()); metadataStore = reader.getMetadataStore(); core = reader.getCoreMetadata(); metadata = reader.getGlobalMetadata(); base.close(); }
private static ArrayList<BatteryData> prepareBatteryData() { ArrayList<BatteryData> batteryList = new ArrayList<BatteryData>(); BufferedReader br = null; String line = ""; String cvsSplitBy = ","; try { ZipInputStream zin = new ZipInputStream(new FileInputStream(Battery_Name)); zin.getNextEntry(); br = new BufferedReader(new InputStreamReader(zin)); while ((line = br.readLine()) != null) { String[] values = line.toLowerCase().split(cvsSplitBy); // line format: SAMSUNG I9500 GALAXY S4, 2600 if (values.length < 2) continue; Matcher matcher = modelRegEx.matcher(values[0]); String model = values[0]; if (matcher.find()) model = matcher.group(0); batteryList.add(new BatteryData(values[0], model, values[1])); } br.close(); } catch (Exception e) { e.printStackTrace(); } finally { if (br != null) { try { br.close(); } catch (Exception e) { } } } return batteryList; }
/** * @return a mutable list * @throws IOException */ public static List<JSSourceFile> getDefaultExterns() throws IOException { InputStream input = CommandLineRunner.class.getResourceAsStream("/externs.zip"); ZipInputStream zip = new ZipInputStream(input); Map<String, JSSourceFile> externsMap = Maps.newHashMap(); for (ZipEntry entry = null; (entry = zip.getNextEntry()) != null; ) { LimitInputStream entryStream = new LimitInputStream(zip, entry.getSize()); externsMap.put( entry.getName(), JSSourceFile.fromInputStream( // Give the files an odd prefix, so that they do not conflict // with the user's files. "externs.zip//" + entry.getName(), entryStream)); } Preconditions.checkState( externsMap.keySet().equals(Sets.newHashSet(DEFAULT_EXTERNS_NAMES)), "Externs zip must match our hard-coded list of externs."); // Order matters, so the resources must be added to the result list // in the expected order. List<JSSourceFile> externs = Lists.newArrayList(); for (String key : DEFAULT_EXTERNS_NAMES) { externs.add(externsMap.get(key)); } return externs; }
public void testDownload() throws Exception { final Long processId = issueProcessAndWaitForTermination(); // zip extension is not required but should be handled final String request = RESTLET_PATH + "/" + processId.longValue() + ".zip"; final MockHttpServletResponse response = getAsServletResponse(request); assertEquals(Status.SUCCESS_OK, Status.valueOf(response.getStatus())); assertEquals(MediaType.APPLICATION_ZIP, MediaType.valueOf(response.getContentType())); assertEquals( "attachment; filename=\"test map.zip\"", response.getHeader("Content-Disposition")); final ByteArrayInputStream responseStream = getBinaryInputStream(response); final ZipInputStream zipIn = new ZipInputStream(responseStream); Set<String> expectedFiles = new HashSet<String>(); expectedFiles.add("README.txt"); expectedFiles.add(VECTOR_LAYER.getLocalPart() + ".shp"); expectedFiles.add(VECTOR_LAYER.getLocalPart() + ".cst"); expectedFiles.add(VECTOR_LAYER.getLocalPart() + ".prj"); expectedFiles.add(VECTOR_LAYER.getLocalPart() + ".dbf"); expectedFiles.add(VECTOR_LAYER.getLocalPart() + ".shx"); // TODO: change this expectation once we normalize the raster file name expectedFiles.add(RASTER_LAYER.getPrefix() + ":" + RASTER_LAYER.getLocalPart() + ".tiff"); Set<String> archivedFiles = new HashSet<String>(); ZipEntry nextEntry; while ((nextEntry = zipIn.getNextEntry()) != null) { archivedFiles.add(nextEntry.getName()); } assertEquals(expectedFiles, archivedFiles); }
private List<ComponentDeclaration> getDeclaredComponents(File jarFile) throws IOException { ZipInputStream zis = new ZipInputStream(new FileInputStream(jarFile)); List<ComponentDeclaration> componentDeclarations = null; List<ComponentDeclaration> componentOverrideDeclarations = null; try { for (ZipEntry entry = zis.getNextEntry(); entry != null && (componentDeclarations == null || componentOverrideDeclarations == null); entry = zis.getNextEntry()) { if (entry.getName().equals(ComponentAnnotationLoader.COMPONENT_LIST)) { componentDeclarations = this.jarLoader.getDeclaredComponents(zis); } else if (entry.getName().equals(ComponentAnnotationLoader.COMPONENT_OVERRIDE_LIST)) { componentOverrideDeclarations = this.jarLoader.getDeclaredComponents(zis); } } } finally { zis.close(); } // Merge all overrides found with a priority of 0. This is purely for backward compatibility // since the // override files is now deprecated. if (componentOverrideDeclarations != null) { if (componentDeclarations == null) { componentDeclarations = new ArrayList<ComponentDeclaration>(); } for (ComponentDeclaration componentOverrideDeclaration : componentOverrideDeclarations) { componentDeclarations.add( new ComponentDeclaration(componentOverrideDeclaration.getImplementationClassName(), 0)); } } return componentDeclarations; }
/** * Constructor. * * @param codeBaseLocator the codebase locator for this codebase * @param file the File containing the zip file (may be a temp file if the codebase was copied * from a nested zipfile in another codebase) */ public ZipInputStreamCodeBase(ICodeBaseLocator codeBaseLocator, File file) throws IOException { super(codeBaseLocator); this.file = file; setLastModifiedTime(file.lastModified()); ZipInputStream zis = new ZipInputStream(new FileInputStream(file)); try { ZipEntry ze; if (DEBUG) { System.out.println("Reading zip input stream " + file); } while ((ze = zis.getNextEntry()) != null) { String name = ze.getName(); if (!ze.isDirectory() && (name.equals("META-INF/MANIFEST.MF") || name.endsWith(".class") || Archive.isArchiveFileName(name))) { entries.add(name); if (name.equals("META-INF/MANIFEST.MF")) { map.put(name, build(zis, ze)); } } zis.closeEntry(); } } finally { zis.close(); } if (DEBUG) { System.out.println("Done with zip input stream " + file); } }
private void loadSharedStringsAndRels(FileInputStream inputStream) { try { int tasksComplete = 0; ZipInputStream zipInputStream = new ZipInputStream(inputStream); ZipEntry zipEntry = null; while ((zipEntry = zipInputStream.getNextEntry()) != null) { String filename = zipEntry.getName(); if (filename.equals("xl/sharedStrings.xml")) { processSharedStrings(zipInputStream); tasksComplete++; } else if (filename.equals("xl/_rels/workbook.xml.rels")) { processRels(zipInputStream); tasksComplete++; } if (tasksComplete == 2) { zipInputStream.close(); break; } } } catch (IOException e) { e.printStackTrace(); } }
/** * Add the entries from the supplied {@link ZipInputStream} to this archive instance. * * @param zipStream The zip stream. * @return This archive instance. * @throws IOException Error reading zip stream. */ public Archive addEntries(ZipInputStream zipStream) throws IOException { AssertArgument.isNotNull(zipStream, "zipStream"); try { ZipEntry zipEntry = zipStream.getNextEntry(); ByteArrayOutputStream outByteStream = new ByteArrayOutputStream(); byte[] byteReadBuffer = new byte[512]; int byteReadCount; while (zipEntry != null) { if (zipEntry.isDirectory()) { addEntry(zipEntry.getName(), (byte[]) null); } else { while ((byteReadCount = zipStream.read(byteReadBuffer)) != -1) { outByteStream.write(byteReadBuffer, 0, byteReadCount); } addEntry(zipEntry.getName(), outByteStream.toByteArray()); outByteStream.reset(); } zipEntry = zipStream.getNextEntry(); } } finally { try { zipStream.close(); } catch (IOException e) { logger.debug("Unexpected error closing EDI Mapping Model Zip stream.", e); } } return this; }
private int extractZipEntry(String out_path, ZipInputStream zip, int total_size, String mes) { BufferedOutputStream out = null; try { out = new BufferedOutputStream(new FileOutputStream(out_path)); } catch (Exception e) { sendMessage(-2, 0, "Failed to create file: " + e.toString()); return -1; } ; int total_read = 0; try { int len = zip.read(buf); while (len >= 0) { if (len > 0) out.write(buf, 0, len); total_read += len; sendMessage(total_read, total_size, mes); len = zip.read(buf); try { Thread.sleep(1); } catch (InterruptedException e) { } } out.flush(); out.close(); } catch (java.io.IOException e) { sendMessage(-2, 0, "Failed to write: " + e.toString()); return -1; } return 0; }
private TreeSet<String> findClasses(String directory, String packageName) throws IOException { TreeSet<String> classes = new TreeSet<String>(); if (directory.startsWith("file:") && directory.contains("!")) { String[] split = directory.split("!"); URL jar = new URL(split[0]); ZipInputStream zip = new ZipInputStream(jar.openStream()); ZipEntry entry = null; while ((entry = zip.getNextEntry()) != null) { if (entry.getName().startsWith("husacct/validate/domain/validation/ruletype") && entry.getName().endsWith(".class")) { final String className = entry.getName().replaceAll("[$].*", "").replaceAll("[.]class", "").replace('/', '.'); classes.add(className); } } } File dir = new File(URLDecoder.decode(directory, "UTF-8")); if (!dir.exists()) { return classes; } File[] files = dir.listFiles(); for (File file : files) { if (file.isDirectory()) { assert !file.getName().contains("."); classes.addAll(findClasses(file.getAbsolutePath(), packageName + "." + file.getName())); } else if (file.getName().endsWith(".class")) { classes.add(packageName + '.' + file.getName().substring(0, file.getName().length() - 6)); } } return classes; }
@Test public void packingALargeFileShouldGenerateTheSameOutputWhenOverwritingAsWhenAppending() throws IOException { File reference = File.createTempFile("reference", ".zip"); String packageName = getClass().getPackage().getName().replace(".", "/"); URL sample = Resources.getResource(packageName + "/macbeth.properties"); byte[] input = Resources.toByteArray(sample); try (CustomZipOutputStream out = ZipOutputStreams.newOutputStream(output, OVERWRITE_EXISTING); ZipOutputStream ref = new ZipOutputStream(new FileOutputStream(reference))) { CustomZipEntry entry = new CustomZipEntry("macbeth.properties"); entry.setTime(System.currentTimeMillis()); out.putNextEntry(entry); ref.putNextEntry(entry); out.write(input); ref.write(input); } byte[] seen = Files.readAllBytes(output); byte[] expected = Files.readAllBytes(reference.toPath()); // Make sure the output is valid. try (ZipInputStream in = new ZipInputStream(Files.newInputStream(output))) { ZipEntry entry = in.getNextEntry(); assertEquals("macbeth.properties", entry.getName()); assertNull(in.getNextEntry()); } assertArrayEquals(expected, seen); }
public ZipEntry getEntry(String entryName) { ZipEntry entry = null; if (_zipfile != null) { entry = _zipfile.getEntry(entryName); } else if (_url != null) { try { URLConnection con = _url.openConnection(); con.connect(); InputStream is = con.getInputStream(); ZipInputStream zis = new ZipInputStream(is); ZipEntry ze; while ((ze = zis.getNextEntry()) != null) { String name = ze.getName(); if (entryName.equals(name)) { entry = ze; break; } } // end while } catch (IOException ex) { entry = null; } // end try } // end if return entry; }
static Hashtable<String, PkgEntry> readJarFile(InputStream in) { Hashtable<String, PkgEntry> tbl = new Hashtable<String, PkgEntry>(); try { ZipInputStream zis = new ZipInputStream(in); ZipEntry ze = zis.getNextEntry(); while (ze != null) { String zname = ze.getName(); if (zname.endsWith(".class")) { String pkgname = getPackageName(zname); if (!tbl.containsKey(pkgname)) { long csize = getCompressedSize(zis); tbl.put(pkgname, new PkgEntry(ze.getSize(), csize)); } else { PkgEntry pe = tbl.get(pkgname); long csize = getCompressedSize(zis); pe.addSizes(ze.getSize(), csize); tbl.put(pkgname, pe); } } ze = zis.getNextEntry(); } } catch (ZipException ex) { Logger.getLogger(JarAnalyzer.class.getName()).log(Level.SEVERE, null, ex); } catch (IOException ex) { Logger.getLogger(JarAnalyzer.class.getName()).log(Level.SEVERE, null, ex); } return tbl; }
public Enumeration<? extends ZipEntry> entries() { Enumeration<? extends ZipEntry> entries = null; if (_zipfile != null) { entries = _zipfile.entries(); } else if (_url != null) { try { URLConnection con = _url.openConnection(); con.connect(); InputStream is = con.getInputStream(); ZipInputStream zis = new ZipInputStream(is); List<ZipEntry> entryList = new ArrayList<ZipEntry>(); ZipEntry ze; while ((ze = zis.getNextEntry()) != null) { entryList.add(ze); } // end while entries = Collections.enumeration(entryList); } catch (IOException ex) { entries = null; } } // end if return entries; }
/** * Extract files from or list a zip archive. * * @param context the current call Context * @param zipFile The pathname of the zip file: tilde expansion (see path.expand) will be * performed. * @param files A character vector of recorded filepaths to be extracted: the default is to * extract all files. * @param exdirUri The directory to extract files to (the equivalent of unzip -d). It will be * created if necessary. * @param list If TRUE, list the files and extract none. The equivalent of unzip -l. * @param overwrite If TRUE, overwrite existing files, otherwise ignore such files. The equivalent * of unzip -o. * @param junkpaths If TRUE, use only the basename of the stored filepath when extracting. The * equivalent of unzip -j. * @return If list = TRUE, a data frame with columns Name, Length (the size of the uncompressed * file) and Date (of class "POSIXct"). Otherwise, a character vector of the filepaths * extracted to, invisibly. * @throws IOException */ @Internal public static SEXP unzip( @Current Context context, String zipFile, Vector files, String exdirUri, boolean list, boolean overwrite, boolean junkpaths) throws IOException { ZipInputStream zin = new ZipInputStream(context.resolveFile(pathExpand(zipFile)).getContent().getInputStream()); try { FileObject exdir = context.resolveFile(exdirUri); if (list) { throw new EvalException("unzip(list=true) not yet implemented"); } ZipEntry entry; while ((entry = zin.getNextEntry()) != null) { if (unzipMatches(entry, files)) { unzipExtract(zin, entry, exdir, junkpaths, overwrite); } } context.setInvisibleFlag(); return new IntArrayVector(0); } finally { zin.close(); } }
private static void unZipFile(InputStream source, FileObject projectRoot) throws IOException { try { ZipInputStream str = new ZipInputStream(source); ZipEntry entry; while ((entry = str.getNextEntry()) != null) { if (entry.isDirectory()) { FileUtil.createFolder(projectRoot, entry.getName()); } else { FileObject fo = FileUtil.createData(projectRoot, entry.getName()); FileLock lock = fo.lock(); try { OutputStream out = fo.getOutputStream(lock); try { FileUtil.copy(str, out); } finally { out.close(); } } finally { lock.releaseLock(); } } } } finally { source.close(); } }
/** * Extracts all files from a zip to disk. * * @param zip data (zip format) * @throws IOException */ private void extractZip(byte[] zip) throws IOException { ZipInputStream zis = null; try { ByteArrayInputStream bais = new ByteArrayInputStream(zip); zis = new ZipInputStream(new BufferedInputStream(bais)); ZipEntry ze = null; // extract all entries Log.d(TAG, "Start extracting backup."); int i = 0; while ((ze = zis.getNextEntry()) != null) { if (!shouldIgnoreZipEntry(ze)) { extractFromZipAndSaveToFile(zis, ze); ++i; } else { Log.d(TAG, "Ignore entry: " + ze.getName()); } } Log.i(TAG, "Extracted " + i + " elements from backup."); } finally { if (zis != null) { try { zis.close(); } catch (IOException e) { Log.w(TAG, "Could not close zip input stream.", e); } } } }
/** * Parse a repository document. * * @param url * @throws IOException * @throws XmlPullParserException * @throws Exception */ void parseDocument(URL url) throws IOException, XmlPullParserException, Exception { if (!visited.contains(url)) { visited.add(url); try { System.out.println("Visiting: " + url); InputStream in = null; if (url.getPath().endsWith(".zip")) { ZipInputStream zin = new ZipInputStream(url.openStream()); ZipEntry entry = zin.getNextEntry(); while (entry != null) { if (entry.getName().equals("repository.xml")) { in = zin; break; } entry = zin.getNextEntry(); } } else { in = url.openStream(); } Reader reader = new InputStreamReader(in); XmlPullParser parser = new KXmlParser(); parser.setInput(reader); parseRepository(parser); } catch (MalformedURLException e) { System.out.println("Cannot create connection to url"); } } }
@Override public String getScript() throws IOException { ZipInputStream zippedIn = null; try { zippedIn = new ZipInputStream(new FileInputStream(getZipFile())); ZipEntry entry; while ((entry = zippedIn.getNextEntry()) != null) { if (entry.getName().equals(getEntryName())) { break; } } if (entry == null) { throw new OpenGammaRuntimeException( "No entry found in zip file " + getZipFile() + " with name " + getEntryName()); } return IOUtils.toString(zippedIn); } catch (FileNotFoundException e) { throw new OpenGammaRuntimeException("Zip file not found: " + getZipFile()); } catch (IOException e) { throw new OpenGammaRuntimeException("Error reading from zip file: " + getZipFile()); } finally { if (zippedIn != null) { try { zippedIn.close(); } catch (IOException e) { } } } }
public static void unZip(String unZipfileName, String mDestPath) { if (!mDestPath.endsWith("/")) { mDestPath = mDestPath + "/"; } FileOutputStream fileOut = null; ZipInputStream zipIn = null; ZipEntry zipEntry = null; File file = null; int readedBytes = 0; byte buf[] = new byte[4096]; try { zipIn = new ZipInputStream(new BufferedInputStream(new FileInputStream(unZipfileName))); while ((zipEntry = zipIn.getNextEntry()) != null) { file = new File(mDestPath + zipEntry.getName()); if (zipEntry.isDirectory()) { file.mkdirs(); } else { // 如果指定文件的目录不存在,则创建之. File parent = file.getParentFile(); if (!parent.exists()) { parent.mkdirs(); } fileOut = new FileOutputStream(file); while ((readedBytes = zipIn.read(buf)) > 0) { fileOut.write(buf, 0, readedBytes); } fileOut.close(); } zipIn.closeEntry(); } } catch (IOException ioe) { ioe.printStackTrace(); } }
/** * Get the preview image of a ggb file. * * @param file * @throws IOException * @return */ public static final BufferedImage getPreviewImage(File file) throws IOException { // just allow preview images for ggb files if (!file.getName().endsWith(".ggb")) { throw new IllegalArgumentException("Preview image source file has to be of the type .ggb"); } FileInputStream fis = new FileInputStream(file); ZipInputStream zip = new ZipInputStream(fis); BufferedImage result = null; // get all entries from the zip archive while (true) { ZipEntry entry = zip.getNextEntry(); if (entry == null) break; if (entry.getName().equals(XML_FILE_THUMBNAIL)) { result = ImageIO.read(zip); break; } // get next entry zip.closeEntry(); } zip.close(); fis.close(); return result; }
static boolean unpackZipTo(Path zipfile, Path destDirectory) throws IOException { boolean ret = true; byte[] bytebuffer = new byte[BUFFERSIZE]; ZipInputStream zipinputstream = new ZipInputStream(new FileInputStream(zipfile.toFile())); ZipEntry zipentry; while ((zipentry = zipinputstream.getNextEntry()) != null) { Path newFile = destDirectory.resolve(zipentry.getName()); if (!Files.exists(newFile.getParent(), LinkOption.NOFOLLOW_LINKS)) { Files.createDirectories(newFile.getParent()); } if (!Files.isDirectory(newFile, LinkOption.NOFOLLOW_LINKS)) { FileOutputStream fileoutputstream = new FileOutputStream(newFile.toFile()); int bytes; while ((bytes = zipinputstream.read(bytebuffer)) > -1) { fileoutputstream.write(bytebuffer, 0, bytes); } fileoutputstream.close(); } zipinputstream.closeEntry(); } zipinputstream.close(); return ret; }
public ZipInputStream createInputStream() throws IOException { ZipInputStream stream = new ZipInputStream(inner.createInputStream()); if (openEntry) { stream.getNextEntry(); } return stream; }
@Test public void shouldSetTimestampOfEntries() throws IOException { Calendar cal = Calendar.getInstance(); cal.set(1999, SEPTEMBER, 10); long old = getTimeRoundedToSeconds(cal.getTime()); long now = getTimeRoundedToSeconds(new Date()); try (CustomZipOutputStream out = ZipOutputStreams.newOutputStream(output)) { ZipEntry oldAndValid = new ZipEntry("oldAndValid"); oldAndValid.setTime(old); out.putNextEntry(oldAndValid); ZipEntry current = new ZipEntry("current"); current.setTime(now); out.putNextEntry(current); } try (ZipInputStream in = new ZipInputStream(Files.newInputStream(output))) { ZipEntry entry = in.getNextEntry(); assertEquals("oldAndValid", entry.getName()); assertEquals(old, entry.getTime()); entry = in.getNextEntry(); assertEquals("current", entry.getName()); assertEquals(now, entry.getTime()); } }
/** * Copies your database from your local assets-folder to the just created empty database in the * system folder, from where it can be accessed and handled. This is done by transfering * bytestream. */ private void copyDataBase() throws IOException { Log.d(TAG, "copyDataBase() called with: " + ""); // Open your local db as the input stream ZipInputStream zipInputStream = new ZipInputStream(context.getAssets().open("data/" + DATABASE_NAME + ".zip")); ZipEntry entry; do { entry = zipInputStream.getNextEntry(); } while (!entry.getName().equals(DATABASE_NAME)); // InputStream myInput = context.getAssets().open(DATABASE_NAME); // Path to the just created empty db String outFileName = DATABASE_PATH + DATABASE_NAME; // Open the empty db as the output stream OutputStream myOutput = new FileOutputStream(outFileName); // transfer bytes from the inputfile to the outputfile byte[] buffer = new byte[1024]; int length; while ((length = zipInputStream.read(buffer)) > 0) { myOutput.write(buffer, 0, length); } // Close the streams myOutput.flush(); myOutput.close(); zipInputStream.close(); }
@Override public void analyze(Document doc, StreamSource src, Writer xrefOut) throws IOException { try (ZipInputStream zis = new ZipInputStream(src.getStream())) { ZipEntry entry; while ((entry = zis.getNextEntry()) != null) { String ename = entry.getName(); if (xrefOut != null) { xrefOut.append("<br/><b>"); Util.htmlize(ename, xrefOut); xrefOut.append("</b>"); } doc.add(new TextField("full", ename, Store.NO)); IFileAnalyzerFactory fac = AnalyzerGuru.find(ename); if (fac instanceof JavaClassAnalyzerFactory) { if (xrefOut != null) { xrefOut.append("<pre>"); } JavaClassAnalyzer jca = (JavaClassAnalyzer) fac.getAnalyzer(); jca.analyze(doc, new BufferedInputStream(zis), xrefOut); if (xrefOut != null) { xrefOut.append("</pre>"); } } } } }