org.xmind.core.internal.zip.ArchivedWorkbook Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of xmindjbehaveplugin Show documentation
Show all versions of xmindjbehaveplugin Show documentation
Plugin that manages JBehave stories storage in XMind mindmap file, which allows design jBehave tests right after the brainstorm
The newest version!
/* ******************************************************************************
* Copyright (c) 2006-2012 XMind Ltd. and others.
*
* This file is a part of XMind 3. XMind releases 3 and
* above are dual-licensed under the Eclipse Public License (EPL),
* which is available at http://www.eclipse.org/legal/epl-v10.html
* and the GNU Lesser General Public License (LGPL),
* which is available at http://www.gnu.org/licenses/lgpl.html
* See http://www.xmind.net/license.html for details.
*
* Contributors:
* XMind Ltd. - initial API and implementation
*******************************************************************************/
package org.xmind.core.internal.zip;
/**
* @author briansun
* @deprecated
*/
public class ArchivedWorkbook {
//extends AbstractArchivedWorkbook {
//
// private static class ZipEntryInputStream extends InputStream {
//
// private ZipFile zipFile;
//
// private InputStream delegate;
//
// public ZipEntryInputStream(ZipFile zipFile, InputStream delegate) {
// this.zipFile = zipFile;
// this.delegate = delegate;
// }
//
// public int available() throws IOException {
// return delegate.available();
// }
//
// public void close() throws IOException {
// try {
// delegate.close();
// } finally {
// zipFile.close();
// }
// }
//
// public int hashCode() {
// return delegate.hashCode();
// }
//
// public synchronized void mark(int readlimit) {
// delegate.mark(readlimit);
// }
//
// public boolean markSupported() {
// return delegate.markSupported();
// }
//
// public int read() throws IOException {
// return delegate.read();
// }
//
// public int read(byte[] b) throws IOException {
// return delegate.read(b);
// }
//
// public int read(byte[] b, int off, int len) throws IOException {
// return delegate.read(b, off, len);
// }
//
// public synchronized void reset() throws IOException {
// delegate.reset();
// }
//
// public long skip(long n) throws IOException {
// return delegate.skip(n);
// }
//
// public String toString() {
// return delegate.toString();
// }
//
// }
//
// private static final List XML_PATHS = Arrays.asList(CONTENT_XML,
// PATH_MARKER_SHEET, STYLES_XML, MANIFEST_XML, META_XML);
//
// /**
// * @param file
// */
// public ArchivedWorkbook(IWorkbook workbook, String file) {
// super(workbook, file);
// }
//
// public OutputStream getEntryOutputStream(String entryPath) {
// //ZipOutputStream os = new ZipOutputStream(
// // new FileOutputStream(getFile()));
// //os.putNextEntry(new ZipEntry(entryPath));
// //return os;
//
// /*
// * We can't provide an output stream for those who wants to insert,
// * replace or delete some entry within a ZIP archive, for the
// * ZipOutputStream will ignore all other existing contents in the
// * archive and leave only the given entry.
// */
// return null;
// }
//
// public InputStream getEntryInputStream(String entryPath) {
// InputStream stream = getZippedStream(entryPath);
// if (stream != null) {
// String password = workbook.getPassword();
// if (password != null) {
// if (map != null) {
// EncryptionData encData = map.get(entryPath);
// if (encData != null) {
// try {
//// BufferedBlockCipher cipher = Crypto
//// .createBlockCipher(false, password, encData);
//// stream = new BlockCipherInputStream(stream, cipher);
// stream = Crypto.createInputStream(stream,
// false, encData, password);
// } catch (CoreException e) {
// Core.getLogger().log(e);
// return null;
// }
// }
// }
// }
// }
// return stream;
// }
//
// /**
// * @param entryPath
// * @return
// */
// private InputStream getZippedStream(String entryPath) {
// try {
// ZipFile zipFile = new ZipFile(getFile());
// try {
// ZipEntry entry = zipFile.getEntry(entryPath);
// if (entry != null) {
// InputStream realInputStream = zipFile.getInputStream(entry);
// if (realInputStream != null)
// return new ZipEntryInputStream(zipFile, realInputStream);
// }
// } catch (Exception e) {
// }
// zipFile.close();
// } catch (Exception e) {
// }
// return null;
// }
//
// public long getTime(String entryPath) {
// try {
// ZipFile zipFile = new ZipFile(getFile());
// try {
// ZipEntry e = zipFile.getEntry(entryPath);
// if (e != null) {
// return e.getTime();
// }
// } finally {
// zipFile.close();
// }
// } catch (Exception e) {
// }
// return -1;
// }
//
// public void setTime(String entryPath, long time) {
// }
//
// public long getSize(String entryPath) {
// try {
// ZipFile zipFile = new ZipFile(getFile());
// try {
// ZipEntry e = zipFile.getEntry(entryPath);
// if (e != null) {
// return e.getSize();
// }
// } finally {
// zipFile.close();
// }
// } catch (Exception e) {
// }
// return -1;
// }
//
// public void save(IArchivedWorkbook source) throws IOException,
// CoreException {
// File tempSource = null;
// if (!isValidSource(source)) {
// String tempDir = Core.getWorkspace().getAbsolutePath(
// IWorkspace.DIR_TEMP);
// tempSource = new File(tempDir, Core.getIdFactory().createId());
// extractTo(tempSource);
// }
//
// FileUtils.ensureFileParent(new File(getFile()));
//
// ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(
// getFile()));
//
// try {
// IManifest manifest = workbook.getManifest();
//
// if (map != null) {
// map.clear();
// }
//
// OutputStream out_CONTENT = getOutputStream(zos, CONTENT_XML,
// manifest);
// DOMUtils.save(workbook, out_CONTENT, true);
// if (out_CONTENT instanceof IChecksumStream)
// saveChecksum(CONTENT_XML, ((IChecksumStream) out_CONTENT)
// .getChecksum());
//
// IMarkerSheet markerSheet = workbook.getMarkerSheet();
// if (!markerSheet.isEmpty()) {
// DOMUtils.save(markerSheet, getOutputStream(zos,
// PATH_MARKER_SHEET, manifest), true);
// }
//
// IStyleSheet styleSheet = workbook.getStyleSheet();
// if (!styleSheet.isEmpty()) {
// OutputStream out_STYLES = getOutputStream(zos, STYLES_XML,
// manifest);
// DOMUtils.save(styleSheet, out_STYLES, true);
// if (out_STYLES instanceof IChecksumStream)
// saveChecksum(STYLES_XML, ((IChecksumStream) out_STYLES)
// .getChecksum());
// }
//
// IMeta meta = workbook.getMeta();
// OutputStream out_META = getOutputStream(zos, META_XML, manifest);
// DOMUtils.save(meta, out_META, true);
// if (out_META instanceof IChecksumStream)
// saveChecksum(META_XML, ((IChecksumStream) out_META)
// .getChecksum());
//
// encapsulate(manifest, source, tempSource, zos);
//
// //zos.putNextEntry(new ZipEntry(MANIFEST_XML));
// OutputStream manifestOutput = getOutputStream(zos, MANIFEST_XML,
// manifest);
// DOMUtils.save(manifest, manifestOutput, true);
//
// clearEncryptionData(manifest);
//
// } finally {
// zos.close();
// if (tempSource != null) {
// FileUtils.delete(tempSource);
// tempSource = null;
// }
// }
// }
//
// /**
// * @param entryPath
// * @param checksum
// */
// private void saveChecksum(String entryPath, String checksum) {
// if (map != null) {
// EncryptionData encData = map.get(entryPath);
// if (encData != null) {
// encData.setChecksum(checksum);
// }
// }
// }
//
// /**
// * @param zippedOutput
// * @param entryName
// * @param manifest
// * @return
// * @throws IOException
// */
// private OutputStream getOutputStream(ZipOutputStream zippedOutput,
// String entryName, IManifest manifest) throws CoreException,
// IOException {
//
// zippedOutput.putNextEntry(new ZipEntry(entryName));
// OutputStream out = new NonCloseOutputStream(zippedOutput);
//
// if (ignoresEncryption(entryName))
// return out;
//
// String password = workbook.getPassword();
//
// if (password == null) {
// return out;
// }
// Document mfDoc = (Document) manifest.getAdapter(Document.class);
// if (mfDoc == null)
// return out;
//
// EncryptionData encData = Crypto.generateEncryptionData(mfDoc);
// if (encData == null)
// return out;
//
// if (map == null)
// map = new HashMap();
// map.put(entryName, encData);
//
// return Crypto.creatOutputStream(out, true, encData, password);
//
//// BufferedBlockCipher cipher = Crypto.createBlockCipher(true, password,
//// encData);
//// return new ChecksumOutputStream(
//// new BlockCipherOutputStream(out, cipher));
// }
//
// private static class NonCloseOutputStream extends FilterOutputStream {
//
// public NonCloseOutputStream(OutputStream out) {
// super(out);
// }
//
// @Override
// public void close() throws IOException {
// // don't close the underlying stream
// }
//
// }
//
// /**
// * @param entryName
// * @return
// */
// private boolean ignoresEncryption(String entryName) {
// return ArchiveConstants.MANIFEST_XML.equals(entryName);
// }
//
// private Map map = null;
//
// /**
// * @param map
// * the map to set
// */
// public void setEncryptionDataMap(Map map) {
// this.map = map;
// }
//
// /**
// * Encapsulate all preserved files from the directory back to the archive.
// *
// * @param manifest
// * @param source
// * @param sourcePath
// * @param target
// */
// private void encapsulate(IManifest manifest, IArchivedWorkbook source,
// File sourcePath, ZipOutputStream target) {
//
// for (IFileEntry entry : manifest.getFileEntries()) {
// if (entry.isDirectory())
// continue;
//
// String path = entry.getPath();
//
// if (!isXmlFile(path)) {
// InputStream is = getInputStream(path, source, sourcePath);
// if (is != null) {
//// ZipEntry ze = new ZipEntry(path);
//// ze.setTime(getTime(path, source, sourcePath));
// try {
// //target.putNextEntry(ze);
// FileUtils.transfer(is, getOutputStream(target, path,
// manifest), true);
// } catch (IOException e) {
// } catch (CoreException e) {
// } finally {
// try {
// is.close();
// } catch (IOException e) {
// }
// }
// }
// }
// insertEncryptionData(entry, path);
// }
// }
//
// /**
// * @param manifest
// */
// private void clearEncryptionData(IManifest manifest) {
// if (map != null) {
// for (EncryptionData encData : map.values()) {
// deleteEncryptionData(encData, manifest);
// }
// }
// }
//
// /**
// * @param encData
// * @param manifest
// */
// private void deleteEncryptionData(EncryptionData encData, IManifest manifest) {
// Element encDataEle = (Element) encData.getAdapter(Element.class);
// if (encDataEle != null) {
// Node p = encDataEle.getParentNode();
// if (p != null) {
// p.removeChild(encDataEle);
// }
// }
// }
//
// /**
// * @param entry
// * @param path
// */
// private void insertEncryptionData(IFileEntry entry, String path) {
// if (map == null || map.isEmpty())
// return;
//
// EncryptionData encData = map.get(path);
// if (encData != null) {
// Element entryEle = (Element) entry.getAdapter(Element.class);
// Element encDataEle = (Element) encData.getAdapter(Element.class);
// if (entryEle != null && encDataEle != null) {
// entryEle.appendChild(encDataEle);
// }
// }
// }
//
// /**
// * Extract all preserved files to directory.
// *
// * @param destPath
// */
// private void extractTo(File destPath) {
// try {
// ZipFile zipFile = new ZipFile(getFile());
// try {
// extract(zipFile, destPath);
// } finally {
// zipFile.close();
// }
// } catch (IOException e) {
// }
// }
//
// private void extract(ZipFile zipFile, File destPath) {
// Enumeration entries = zipFile.entries();
// while (entries.hasMoreElements()) {
// ZipEntry entry = entries.nextElement();
// String path = entry.getName();
// if (!isXmlFile(path)) {
// try {
// InputStream is = zipFile.getInputStream(entry);
// if (is != null) {
// File f = FileUtils.ensureFileParent(new File(destPath,
// path));
// OutputStream os = new FileOutputStream(f);
// FileUtils.transfer(is, os);
// f.setLastModified(entry.getTime());
// }
// } catch (IOException e) {
// }
// }
// }
// }
//
// /**
// * Checks whether a directory is needed for a re-encapsulation action.
// *
// * @param source
// * @return Whether to create a temporary directory.
// */
// private boolean isValidSource(IArchivedWorkbook source) {
// return source != null && !equals(source);
// }
//
// private InputStream getInputStream(String entryPath,
// IArchivedWorkbook source, File tempSource) {
//
// if (isValidSource(source)) {
// return source.getEntryInputStream(entryPath);
// } else if (tempSource != null) {
// try {
// return new FileInputStream(new File(tempSource, entryPath));
// } catch (FileNotFoundException e) {
// }
// }
// return null;
// }
//
//// private long getTime(String entryPath, IArchivedWorkbook source,
//// File tempSource) {
//// if (isValidSource(source)) {
//// return source.getTime(entryPath);
//// } else if (tempSource != null) {
//// File f = new File(tempSource, entryPath);
//// if (f.exists())
//// return f.lastModified();
//// }
//// return System.currentTimeMillis();
//// }
//
// private static boolean isXmlFile(String path) {
// return XML_PATHS.contains(path);
// }
//
// public boolean equals(Object obj) {
// if (obj == this)
// return true;
// if (obj == null || !(obj instanceof ArchivedWorkbook))
// return false;
// ArchivedWorkbook that = (ArchivedWorkbook) obj;
// return new File(getFile()).equals(new File(that.getFile()));
// }
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy