/** * Clients must call this when done to close the archives */ public void release() { if (dependentArchives == null) return; for (int i = 0; i < dependentArchives.size(); i++) { Archive anArchive = (Archive) dependentArchives.get(i); if (anArchive.isOpen()) anArchive.close(); } }
public void closeOpenArchives() { if (getOpenArchives().isEmpty()) return; List opened = new ArrayList(getOpenArchives().size()); Iterator it = getOpenArchives().keySet().iterator(); while (it.hasNext()) { opened.add(it.next()); } for (int i = 0; i < opened.size(); i++) { Archive anArchive = (Archive) opened.get(i); anArchive.close(); } }
/** * Special case for ejb jar files, because of the need to support non-compliant 1.0 jars */ protected Archive openSpecificArchive(Archive anArchive, RootEJBJarDescriminatorImpl disc) throws OpenFailureException { Archive specific = openSpecificArchive(anArchive, (ArchiveTypeDiscriminator) disc); if (specific == anArchive) { //The discriminator failed to convert the archve to an ejb jar file anArchive.close(); throw new OpenFailureException(disc.getUnableToOpenMessage()); } return specific; }
/** * @see com.ibm.etools.commonarchive.CommonarchiveFactory */ public java.lang.String[] getManifestClassPathValues(java.lang.String uri) throws org.eclipse.jst.j2ee.commonarchivecore.internal.exception.OpenFailureException { Archive anArchive = primOpenArchive(uri); String[] result = anArchive.getManifest().getClassPathTokenized(); anArchive.close(); return result; }
public void close() { try { if (commonArchive != null) { commonArchive.close(); } if (archive != null) { JavaEEArchiveUtilities.INSTANCE.closeArchive(archive); } } catch (RuntimeException e) { Logger.getLogger().logError(e); throw e; } }
/** * @see com.ibm.etools.commonarchive.Archive */ public void close() { getLoadStrategy().close(); releaseClassLoader(); getCommonArchiveFactory().archiveClosed(this); if (isIndexed()) { List archives = getArchiveFiles(); for (int i = 0; i < archives.size(); i++) { ((Archive) archives.get(i)).close(); } } }
/** * Take the primitive archive and run it through the list of discriminators to convert it to the * correct specialized type; after after conversion, tell the archive to initalize itself if * necessary. */ protected Archive openSpecificArchive(Archive anArchive, ArchiveTypeDiscriminator disc) throws OpenFailureException { if (!disc.canImport(anArchive)) { anArchive.close(); throw new OpenFailureException(disc.getUnableToOpenMessage()); } Archive specificArchive = disc.openArchive(anArchive); specificArchive.initializeAfterOpen(); return specificArchive; }
protected boolean isArchiveValid() { if (archive != null) { return true; } Archive anArchive = null; try { anArchive = CommonarchiveFactory.eINSTANCE.primOpenArchive(getArchiveOptions(), getArchiveURI()); ArchiveTypeDiscriminator disc = getDiscriminator(); return null == disc || disc.canImport(anArchive); } catch (Exception e) { return false; } finally { if (anArchive != null) { anArchive.close(); } } }
public static int getArchiveType(Archive anArchive) { int type = ImportUtil.UNKNOWN; try { try { if (anArchive.isEJBJarFile()) type = ImportUtil.EJBJARFILE; else if (anArchive.isWARFile()) type = ImportUtil.WARFILE; else if (anArchive.isApplicationClientFile()) type = ImportUtil.CLIENTJARFILE; else if (anArchive.isRARFile()) type = ImportUtil.RARFILE; else if (anArchive.isEARFile()) type = ImportUtil.EARFILE; } catch (Exception e) { //Ignore } } finally { if (anArchive != null) anArchive.close(); } return type; }
public static int getFileType(String fileName) { Archive anArchive = null; try { try { anArchive = CommonarchiveFactoryImpl.getActiveFactory().openArchive(fileName); int archiveType = getArchiveType(anArchive); if (archiveType == UNKNOWN && isImportClassType(fileName)) return IMPORTCLASSTYPE; return archiveType; } catch (Exception e) { if (isImportClassType(fileName)) return IMPORTCLASSTYPE; return UNKNOWN; } } finally { if (anArchive != null && anArchive.isOpen()) anArchive.close(); } }
public synchronized IReferenceCountedArchive openArchive(EnterpriseBinaryComponentHelper helper) throws OpenFailureException { ArchiveOptions options = helper.getArchiveOptions(); String archiveURI = helper.getArchiveURI(); options.setLoadStrategy(createBinaryLoadStrategy(helper)); Archive anArchive = CommonarchiveFactory.eINSTANCE.primOpenArchive(options, archiveURI); ArchiveTypeDiscriminator discriminator = helper.getDiscriminator(); if (!discriminator.canImport(anArchive)) { anArchive.close(); throw new OpenFailureException(discriminator.getUnableToOpenMessage()); } IReferenceCountedArchive specificArchive = (IReferenceCountedArchive) discriminator.openArchive(anArchive); specificArchive.setEnterpriseBinaryComponentHelper(helper); specificArchive.initializeAfterOpen(); specificArchive.access(); componentsToArchives.put(helper.getComponent(), specificArchive); return specificArchive; } }
public String[] getManifestClasspath() { if (null == manifestClasspath) { Archive archive = EnterpriseBinaryComponentHelper.ArchiveCache.getInstance().getArchive(this); if (null == archive) { EnterpriseBinaryComponentHelper helper = EnterpriseBinaryComponentHelper.getHelper(this); try { archive = helper.accessArchive(); ArchiveManifest manifest = archive.getManifest(); manifestClasspath = manifest.getClassPathTokenized(); } catch (Exception e) { } finally { if (null != archive) { archive.close(); } if (null != helper) { helper.dispose(); } } } else { ArchiveManifest manifest = archive.getManifest(); manifestClasspath = manifest.getClassPathTokenized(); } if (manifestClasspath == null) { manifestClasspath = new String[0]; } } return manifestClasspath; } }
} finally { if(archive != null) archive.close();
} finally { if (anArchive != null && anArchive.isOpen()) anArchive.close();