com.tangosol.dev.component.OSStorage Maven / Gradle / Ivy
/*
* Copyright (c) 2000, 2020, Oracle and/or its affiliates.
*
* Licensed under the Universal Permissive License v 1.0 as shown at
* http://oss.oracle.com/licenses/upl.
*/
package com.tangosol.dev.component;
import com.tangosol.dev.assembler.ClassFile;
import com.tangosol.util.ErrorList;
import com.tangosol.util.StringTable;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.File;
import java.io.IOException;
import java.util.Enumeration;
/**
* OSStorage loads and saves single-dimension (no versioning, localization,
* or customization) Components from and to an OS file system.
*
* @version 1.00, 02/04/98
* @author Cameron Purdy
*/
public class OSStorage
extends BaseStorage
{
// ----- constructors ---------------------------------------------------
/**
* Create a storage object backed by the specified path.
*
* @param path the java.lang.String object containing the OS path name
* to read/write Components from/to
*/
public OSStorage(String path)
{
this(new File(path));
}
/**
* Create a storage object backed by the specified path.
*
* @param path the java.io.File object containing the OS path to
* read/write Components from/to
*/
public OSStorage(File path)
{
boolean fValid;
if (!path.isAbsolute())
{
try
{
path = path.getCanonicalFile();
}
catch (IOException e) {}
}
if (path.exists())
{
if (!path.canRead()) // || !path.canWrite())
{
throw new IllegalArgumentException(CLASS + ": Read access required!");
}
fValid = path.isDirectory();
}
else
{
// defer the directory creation
fValid = path.getParentFile() != null && path.getParentFile().exists();
}
if (!fValid)
{
throw new IllegalArgumentException(CLASS + ": Invalid directory: " + path.getPath());
}
m_path = path;
//ensureStorageDirectories();
}
// ----- Components -----------------------------------------------------
/**
* Load the specified Component.
*
* @param sName fully qualified Component Definition name
* @param fReadOnly true if the loaded component will be read-only
* @param errlist the ErrorList object to log any derivation/
* modification errors to
*
* @return the specified Component Definition or null
*
* @exception ComponentException if an unrecoverable error occurs
*
*/
public Component loadComponent(String sName, boolean fReadOnly, ErrorList errlist)
throws ComponentException
{
if (sName.length() == 0)
{
sName = ROOT;
}
/* gg: 2001.4.25 allow JCS modifications
else if (!Component.isQualifiedNameLegal(sName))
{
throw new ComponentException(CLASS +
".loadComponent: Illegal name -- " + sName);
}
*/
try
{
byte[] ab = loadFile(T_COMPONENT, sName);
if (ab == null)
{
/*
if (sName == ROOT)
{
return Component.getRootSuper(this);
}
*/
return Component.isQualifiedNameLegal(sName) ? null : loadSignature(sName);
}
Component cd = new Component(
new DataInputStream(new ByteArrayInputStream(ab)));
// case-sensitive check
if (!sName.equals(ROOT) && !sName.equals(cd.getQualifiedName()))
{
out("Component case-sensitive check failed: expected=" +
sName + ", actual=" + cd.getQualifiedName());
return null;
}
if (fReadOnly)
{
cd.setModifiable(false);
}
return cd;
}
catch (IOException e)
{
out(e);
throw new ComponentException(e.toString());
}
}
/**
* Store the specified Component.
*
* @param cd the Component Definition
* @param errlist the ErrorList object to log any derivation/modification
* errors to
*
* @exception ComponentException if an unrecoverable error occurs
*/
public void storeComponent(Component cd, ErrorList errlist)
throws ComponentException
{
try
{
if (Trait.DEBUG)
{
out();
out("***OSStorage*** Component before finalizeExtract:");
cd.dump();
}
cd.finalizeExtract(this, errlist);
if (Trait.DEBUG)
{
out();
out("***OSStorage*** Component after finalizeExtract:");
cd.dump();
}
String sName = cd.getQualifiedName();
if (sName.length() == 0)
{
sName = ROOT;
}
if (cd.isDiscardable())
{
removeComponent(sName);
}
else
{
ByteArrayOutputStream stream = new ByteArrayOutputStream();
cd.save(new DataOutputStream(stream));
storeFile(T_COMPONENT, sName, stream.toByteArray());
}
}
catch (IOException e)
{
throw new ComponentException(e.toString());
}
}
/**
* Remove the specified Component.
*
* @param sName fully qualified Component Definition name
*
* @exception ComponentException if an unrecoverable error occurs
*/
public void removeComponent(String sName)
throws ComponentException
{
try
{
removeFile(T_COMPONENT, sName);
}
catch (IOException e)
{
throw new ComponentException(e.toString());
}
try
{
String sClz = Component.isQualifiedNameLegal(sName) ?
DataType.getComponentClassName(sName) : sName;
removeFile(T_CLASS, sClz);
removeFile(T_JAVA, sClz);
}
catch (IOException e) {}
}
// ----- Java Class Signatures ------------------------------------------
/**
* Load the specified Class Signature.
*
* @param sName qualified Java Class Signature (JCS) name
*
* @return the specified Class Signature
*
* @exception ComponentException if an unrecoverable error occurs
*/
public Component loadSignature(String sName)
throws ComponentException
{
try
{
byte[] ab = loadFile(T_SIGNATURE, sName);
if (ab == null)
{
return null;
}
Component cd = new Component(new DataInputStream(new ByteArrayInputStream(ab)));
// case-sensitive check
if (!sName.equals(cd.getQualifiedName()))
{
///////////////////////////////////////////////////////////////////////////
// There are valid scenarios where this condition occurs (at least on the
// NT filing system).
//
// For example the Java compiler when evaluating the statement:
//
// char ch = java.awt.event.KeyEvent.VK_ENTER;
//
// tries to find the class that this applies to. In doing so, the compiler
// first tries to load in order the signatures "java", "java.awt",
// "java.awt.event", and "java.awt.event.KeyEvent" which is successful.
//
// Since there is a class "java.awt.Event", we will encounter this
// case-sensitivity check when on the NT filing system during the attempt
// to load the signature "java.awt.event".
//
// Because of this, the following message has been removed.
//
// out("Signature case-sensitive check failed: expected=" + sName +
// ", actual=" + cd.getQualifiedName());
///////////////////////////////////////////////////////////////////////////
return null;
}
return cd;
}
catch (IOException e)
{
throw new ComponentException(e.toString());
}
}
/**
* Store the specified generated Java Class Signature.
*
* @param cdJCS the Java Class Signature
*
* @exception ComponentException if an unrecoverable error occurs
*/
public void storeSignature(Component cdJCS)
throws ComponentException
{
try
{
ByteArrayOutputStream stream = new ByteArrayOutputStream();
cdJCS.save(new DataOutputStream(stream));
storeFile(T_SIGNATURE, cdJCS.getName(), stream.toByteArray());
}
catch (IOException e)
{
throw new ComponentException(e.toString());
}
}
// ----- Classes --------------------------------------------------------
/**
* Load the original (before any customization takes place) Java Class.
*
* @param sName fully qualified Java Class name
*
* @return the specified Class structure
*
* @exception ComponentException if an unrecoverable error occurs
*/
public ClassFile loadOriginalClass(String sName)
throws ComponentException
{
// OSStorage is not expected to carry the original classes,
// only the JarStorage is.
return null;
}
/**
* Load the specified generated Java Class.
*
* @param sName fully qualified Java Class name
*
* @return the specified Class structure
*
* @exception ComponentException if an unrecoverable error occurs
*/
public ClassFile loadClass(String sName)
throws ComponentException
{
try
{
String sClass = sName.replace('.', '/');
byte[] abClass = loadFile(T_CLASS, sName);
if (abClass == null)
{
return null;
}
ClassFile clsf = new ClassFile(new DataInputStream(
new ByteArrayInputStream(abClass)));
if (clsf.getName().equals(sClass))
{
return clsf;
}
else
{
out("Class case-sensitive check failed: expected=" + sClass +
", actual=" + clsf.getName());
return null;
}
}
catch (IOException e)
{
throw new ComponentException(e.toString());
}
}
/**
* Store the specified generated Java Class along with its listing
*
* @param clz the generated Class structure to store
* @param sListing (optional) the java listing of the class
*
* @exception ComponentException if an unrecoverable error occurs
*/
public void storeClass(ClassFile clz, String sListing)
throws ComponentException
{
try
{
ByteArrayOutputStream stream = new ByteArrayOutputStream();
clz.save(new DataOutputStream(stream));
String sClass = clz.getName();
storeFile(T_CLASS, sClass, stream.toByteArray());
if (sListing != null)
{
storeFile(T_JAVA, sClass, sListing.getBytes());
}
}
catch (IOException e)
{
throw new ComponentException(e.toString());
}
}
// ----- Java -------------------------------------------------------------
/**
* Load the source code for the specified (original) Java class.
*
* @param sName fully qualified Java Class name
*
* @return the specified Java source code as a String
*
* @exception IOException if an unrecoverable error occurs
*/
public String loadJava(String sName)
throws IOException
{
// OSStorage is not expected to carry the original Java source,
// only the JarStorage is.
return null;
}
// ----- Resources --------------------------------------------------------
/**
* Load the original (before any customization takes place) resource.
*
* @param sName fully qualified resource name
*
* @return the specified resource as a byte array
*
* @exception IOException if an unrecoverable error occurs
*/
public byte[] loadOriginalResource(String sName)
throws IOException
{
// OSStorage is not expected to carry the original resource,
// only the JarStorage is.
return null;
}
/**
* Load the Resource Signature.
*
* @param sName fully qualified resource name
*
* @return the specified Resource Signature as a byte array
*
* @exception IOException if an unrecoverable error occurs
*/
public byte[] loadResourceSignature(String sName)
throws IOException
{
return loadFile(T_RES_SIG, sName);
}
/**
* Store the specified Resource Signature.
*
* @param sName fully qualified resource name
* @param abData the specified Resource Signature as a byte array
*
* @exception IOException if an unrecoverable error occurs
*/
public void storeResourceSignature(String sName, byte[] abData)
throws IOException
{
if (abData == null) // discardable
{
removeResourceSignature(sName);
}
else
{
storeFile(T_RES_SIG, sName, abData);
}
}
/**
* Remove the specified Resource Signature
*
* @param sName fully qualified resource name
*
* @exception IOException if an unrecoverable error occurs
*/
public void removeResourceSignature(String sName)
throws IOException
{
removeFile(T_RES_SIG, sName);
removeFile(T_RES_BINARY, sName);
}
/**
* Load the generated resource.
*
* @param sName fully qualified resource name
*
* @return the specified resource as a byte array
*
* @exception IOException if an unrecoverable error occurs
*/
public byte[] loadResource(String sName)
throws IOException
{
return loadFile(T_RES_BINARY, sName);
}
/**
* Store the specified resource.
*
* @param sName fully qualified resource name
* @param abData the specified resource as a byte array
*
* @exception IOException if an unrecoverable error occurs
*/
public void storeResource(String sName, byte[] abData)
throws IOException
{
if (abData == null)
{
removeFile(T_RES_BINARY, sName);
}
else
{
storeFile(T_RES_BINARY, sName, abData);
}
}
// ---- component managment --------------------------------------------
/**
* Return a StringTable which contains the names of Component Definitions
* (CD) that derive from the specified Component Definition
*
* @param sComponent the qualified CD name
* @param fQualify if set to true, return fully qualified CD names;
* otherwise -- non-qualified names
*
* @return StringTable object with Component Definition names as keys
*/
public StringTable getSubComponents(String sComponent, boolean fQualify)
{
Object oLocator = getLocator();
if (sComponent == null || sComponent.length() == 0)
{
StringTable tbl = new StringTable();
sComponent = Component.getRootName();
if (existsFile(T_COMPONENT, sComponent))
{
tbl.put(sComponent, oLocator);
}
return tbl;
}
StringTable tblSub = getFiles(T_COMPONENT, sComponent);
if (tblSub == null)
{
return new StringTable();
}
if (fQualify && !tblSub.isEmpty())
{
Enumeration enmr = tblSub.keys();
for (tblSub = new StringTable(); enmr.hasMoreElements();)
{
tblSub.put(sComponent + '.' + (String) enmr.nextElement(), oLocator);
}
}
return tblSub;
}
/**
* Return a StringTable which contains the names of Component Definitions
* (CD) that belong to the specified package
*
* @param sPackage the qualified package name
* @param fQualify if set to true, return fully qualified CD names;
* otherwise -- non-qualified names
*
* @return StringTable object with CD names as keys
*/
public StringTable getPackageComponents(String sPackage, boolean fQualify)
{
return getSubComponents(sPackage, fQualify);
}
/**
* Return a StringTable which contains the names of sub-packages in
* the specified component package
*
* @param sPackage the qualified package name; pass null to retrieve
* the top level component packages
* @param fQualify if set to true, return fully qualified package names;
* otherwise -- non-qualified names
* @param fSubs if set to true, returns the entire tree of sub-packages
*
* @return StringTable object with package names as keys
*/
public StringTable getComponentPackages(String sPackage, boolean fQualify, boolean fSubs)
{
if (fSubs)
{
fQualify = true;
}
StringTable tblSub = getSubdirectories(T_COMPONENT, sPackage);
if (tblSub == null)
{
return new StringTable();
}
if (fQualify && !tblSub.isEmpty())
{
Object oLocator = getLocator();
Enumeration enmr = tblSub.keys();
for (tblSub = new StringTable(); enmr.hasMoreElements();)
{
String sSubPackage =
(sPackage == null ? "" : sPackage + '.') + (String) enmr.nextElement();
tblSub.put(sSubPackage, oLocator);
if (fSubs)
{
tblSub.addAll(getComponentPackages(sSubPackage, true, true));
}
}
}
return tblSub;
}
/**
* Return a StringTable which contains the names of Java Class Signature
* (JCS) names that belong to the specified java class package
* (i.e. "javax.swing")
*
* @param sPackage the qualified package name
* @param fQualify if set to true, return fully qualified JCS names;
* otherwise -- non-qualified names
*
* @return StringTable object with JCS names as keys
*/
public StringTable getPackageSignatures(String sPackage, boolean fQualify)
{
// persistent Signatures in OSStorage...
// since we don't ship the UI for cretaing those
// this could only happen during in-house testing
StringTable tblJCS = getFiles(T_SIGNATURE, sPackage);
// customizations for JCSs are stored as Component Definitions
StringTable tblDelta = getFiles(T_COMPONENT, sPackage);
if (tblDelta != null)
{
if (sPackage == null)
{
tblDelta.remove("Root");
tblDelta.remove("Component");
}
if (tblJCS == null)
{
tblJCS = tblDelta;
}
else
{
tblJCS.putAll(tblDelta);
}
}
if (tblJCS == null)
{
return new StringTable();
}
if (fQualify && sPackage != null && !tblJCS.isEmpty())
{
Object oLocator = getLocator();
Enumeration enmr = tblJCS.keys();
for (tblJCS = new StringTable(); enmr.hasMoreElements();)
{
tblJCS.put(sPackage + '.' + (String) enmr.nextElement(), oLocator);
}
}
return tblJCS;
}
/**
* Return a StringTable which contains the names of sub-packages in
* the specified java class package
* (i.e. "javax.swing" is a sub-package of "javax" package)
*
* @param sPackage the qualified package name; pass null to retrieve
* the top level java class packages
* @param fQualify if set to true, return fully qualified package names;
* otherwise -- non-qualified names
* @param fSubs if set to true, returns the entire tree of sub-packages
*
* @return StringTable object with package names as keys
*/
public StringTable getSignaturePackages(String sPackage, boolean fQualify, boolean fSubs)
{
if (fSubs)
{
fQualify = true;
}
// persistent Signatures in OSStorage...
// since we don't ship the UI for creating those
// this could only happen during in-house testing
StringTable tblSub = getSubdirectories(T_SIGNATURE, sPackage);
// customizations for JCSs are stored as Component Definitions
StringTable tblDelta = getSubdirectories(T_COMPONENT, sPackage);
if (tblDelta != null)
{
if (sPackage == null)
{
tblDelta.remove("Component");
}
if (tblSub == null)
{
tblSub = tblDelta;
}
else
{
tblSub.putAll(tblDelta);
}
}
if (tblSub == null)
{
return new StringTable();
}
if (fQualify && !tblSub.isEmpty())
{
Object oLocator = getLocator();
Enumeration enmr = tblSub.keys();
for (tblSub = new StringTable(); enmr.hasMoreElements();)
{
String sSubPackage =
(sPackage == null ? "" : sPackage + '.') + (String) enmr.nextElement();
tblSub.put(sSubPackage, oLocator);
if (fSubs)
{
tblSub.addAll(getSignaturePackages(sSubPackage, true, true));
}
}
}
return tblSub;
}
/**
* Return a StringTable which contains the names of resource
* names that belong to the specified package
* (i.e. "img/tde")
*
* @param sPackage the qualified package name
* @param fQualify if set to true, return fully qualified resource names;
* otherwise -- non-qualified names
*
* @return StringTable object with JCS names as keys
*/
public StringTable getPackageResources(String sPackage, boolean fQualify)
{
StringTable tblRes = getFiles(T_RES_SIG, sPackage);
if (tblRes == null)
{
return new StringTable();
}
if (fQualify && sPackage != null && !tblRes.isEmpty())
{
Object oLocator = getLocator();
Enumeration enmr = tblRes.keys();
for (tblRes = new StringTable(); enmr.hasMoreElements();)
{
tblRes.put(sPackage + '/' + (String) enmr.nextElement(), oLocator);
}
}
return tblRes;
}
/**
* Return a StringTable which contains the names of sub-packages in
* the specified resource package
* (i.e. "img/tde" is a sub-package of "img" package)
*
* @param sPackage the qualified package name; pass null to retrieve
* the top level resource packages
* @param fQualify if set to true, return fully qualified package names;
* otherwise -- non-qualified names
* @param fSubs if set to true, returns the entire tree of sub-packages
*
* @return StringTable object with package names as keys
*/
public StringTable getResourcePackages(String sPackage, boolean fQualify, boolean fSubs)
{
if (fSubs)
{
fQualify = true;
}
StringTable tblSub = getSubdirectories(T_RES_SIG, sPackage);
if (tblSub == null)
{
return new StringTable();
}
if (fQualify && !tblSub.isEmpty())
{
Object oLocator = getLocator();
Enumeration enmr = tblSub.keys();
for (tblSub = new StringTable(); enmr.hasMoreElements();)
{
String sSubPackage =
(sPackage == null ? "" : sPackage + '/') + (String) enmr.nextElement();
tblSub.put(sSubPackage, oLocator);
if (fSubs)
{
tblSub.addAll(getResourcePackages(sSubPackage, true, true));
}
}
}
return tblSub;
}
// ----- helpers --------------------------------------------------------
/**
* Find out whether or not the specified item is stored in this storage
*
* @param nType the enumerated item type
* @param sName the name of the item, potentially dot-delimited
*
* @return true if the item is stored in this storage; false otherwise
*/
protected boolean existsFile(int nType, String sName)
{
try
{
return buildFile(nType, sName, false).exists();
}
catch (IOException e)
{
return false;
}
}
/**
* Read the contents of the specified item as a byte array.
*
* @param nType the enumerated item type
* @param sName the name of the item, potentially dot-delimited
*
* @return the file contents as a byte array; null if the specified
* file does not exist
*/
protected byte[] loadFile(int nType, String sName)
throws IOException
{
File file = buildFile(nType, sName, false);
if (!file.isFile())
{
return null;
}
return read(file);
}
/**
* Write the binary contents of the specified item.
*
* @param nType the enumerated item type
* @param sName the name of the item, potentially dot-delimited
* @param abItem the binary contents to write
*/
protected void storeFile(int nType, String sName, byte[] abItem)
throws IOException
{
File file = buildFile(nType, sName, true);
if (file.isFile())
{
if (equalsDeep(abItem, read(file)))
{
// no change -- no store
return;
}
if (nType == T_COMPONENT && !file.canWrite())
{
throw new IOException("Read-only component: "
+ file);
}
file.delete();
}
FileOutputStream stream = new FileOutputStream(file);
try
{
stream.write(abItem);
}
finally
{
try
{
stream.close();
}
catch (IOException e) {}
}
}
/**
* Remove the file from the storage.
*
* @param nType the enumerated item type
* @param sName the name of the item, potentially dot-delimited
*/
protected void removeFile(int nType, String sName)
throws IOException
{
File file = buildFile(nType, sName, false);
if (!file.isFile())
{
return;
}
File dir = file.getParentFile();
file.delete();
// remove all children classes
if (nType == T_CLASS || nType == T_JAVA)
{
File[] aFile = dir.listFiles();
if (aFile != null)
{
String sPref = sName.substring(sName.lastIndexOf('.') + 1) + '$';
for (int i = 0, c = aFile.length; i < c; i++)
{
file = aFile[i];
if (file.getName().startsWith(sPref))
{
file.delete();
}
}
}
}
// clean up all empty parent directories
while (!dir.equals(m_path))
{
if (!emptyDir(dir))
{
break;
}
dir = dir.getParentFile();
}
}
/**
* Clean-up the specified directory of all empty subdirectories
* and remove it if the directory becomes empty
*
* @param dir the directory to check
*
* @return true if the directory has been removed; false otherwise
*/
private boolean emptyDir(File dir)
{
azzert(dir.isDirectory(), "Not a directory: " + dir);
File[] files = dir.listFiles();
for (int i = 0; i < files.length; ++i)
{
File file = files[i];
// if at least one the file must exist,
// then the directory itself must exist
if (!file.isDirectory() || !emptyDir(file))
{
return false;
}
}
// remove this directory
dir.delete();
return true;
}
/**
* Build the full file path for loading/storing some item from/to the OS
* repository.
*
* @param nType the item type
* @param sName the name of the item, potentially dot-delimited
* @param fEnsureDir true if the item is going to be stored and the
* directories therefore may need to be created
*
* @return the full file path as a java.io.File object
*/
protected File buildFile(int nType, String sName, boolean fEnsureDir)
throws IOException
{
sName = SUBDIR[nType] + '/' + sName;
if (nType < T_RES_SIG)
{
sName = sName.replace('.', '/');
}
File file = m_path;
int ofCur = 0;
int ofSep = sName.indexOf('/');
while (true)
{
if (fEnsureDir && !file.isDirectory() && !file.mkdir())
{
throw new IOException("Unable to create directory " + file);
}
if (ofSep >= 0)
{
file = new File(file, sName.substring(ofCur, ofSep));
ofCur = ofSep + 1;
ofSep = sName.indexOf('/', ofCur);
}
else
{
return new File(file, sName.substring(ofCur) + SUFFIX[nType]);
}
}
}
/**
* Build the full directory path for enumerating some item from the OS
* repository.
*
* @param nType the item type
* @param sPackage the name of the package (directory), potentially dot-delimited
* if null, return the top level directory
*
* @return the full file path as a File object; null if the specified
* package does not exist
*/
protected File buildDirectory(int nType, String sPackage)
{
if (sPackage == null || sPackage.length() == 0)
{
sPackage = SUBDIR[nType];
}
else
{
sPackage = SUBDIR[nType] + '/' + sPackage;
}
if (nType < T_RES_SIG)
{
sPackage = sPackage.replace('.', '/');
}
File dir = m_path;
int ofCur = 0;
int ofSep;
do
{
ofSep = sPackage.indexOf('/', ofCur);
dir = new File(dir, ofSep >= 0 ?
sPackage.substring(ofCur, ofSep) : sPackage.substring(ofCur));
if (!dir.isDirectory())
{
return null;
}
ofCur = ofSep + 1;
} while (ofSep >= 0);
return dir;
}
/**
* Return the StringTable that contains the files names of the specified type
* in the specified package (directory) in the OS repository
*
* @param nType the item type
* @param sPackage the name of the package, potentially dot-delimited
*
* @return the StringTable object with [non-qualified] file names as keys
* and the storage locator objects as elements; null if specified
* package does not exist
*/
protected StringTable getFiles(int nType, String sPackage)
{
File dir = buildDirectory(nType, sPackage);
if (dir == null)
{
return null;
}
String sSuffix = SUFFIX[nType];
int iSuffix = sSuffix.length();
StringTable tblFiles = new StringTable();
Object oLocator = getLocator();
String[] asName = dir.list();
int cNames = asName.length;
for (int c = 0; c < cNames; ++c)
{
String sName = asName[c];
if (sName.toLowerCase().endsWith(sSuffix))
{
// make sure that this file can in fact be
// accessed with the correct case suffix
sName = sName.substring(0, sName.length() - iSuffix);
File file = new File(dir, sName + sSuffix);
if (file.isFile())
{
tblFiles.put(sName, oLocator);
}
}
}
return tblFiles;
}
/**
* Return the StringTable that contains the sub-package names of the specified
* type in the specified package (directory) in the OS repository
*
* @param nType the item type
* @param sPackage the name of the package, potentially dot-delimited;
* if null, enumerate the top level packages
*
* @return the StringTable object with [non-qualified] subdirectory names as keys
* and the storage locator objects as elements; null if specified package
* does not exist
*/
protected StringTable getSubdirectories(int nType, String sPackage)
{
File dir = buildDirectory(nType, sPackage);
if (dir == null)
{
return null;
}
StringTable tblSub = new StringTable();
Object oLocator = getLocator();
String[] asName = dir.list();
int cNames = asName.length;
for (int i = 0; i < cNames; i++)
{
String sName = asName[i];
File file = new File(dir, sName);
if (file.isDirectory())
{
tblSub.put(sName, oLocator);
}
}
return tblSub;
}
/**
* Provide a short human-readable description of the trait.
*
* @return a human-readable description of this trait
*/
public String toString()
{
return CLASS + '(' + m_path + ')';
}
// ----- data members ---------------------------------------------------
/**
* The name of this class.
*/
private static final String CLASS = "OSStorage";
/**
* The OS repository subdirectory for Component Definition Binaries.
*/
private static final int T_COMPONENT = 0;
/**
* The OS repository subdirectory for Java Class Signature.
*/
private static final int T_SIGNATURE = 1;
/**
* The OS repository subdirectory for Java Classes.
*/
private static final int T_CLASS = 2;
/**
* The OS repository subdirectory for Java Source (listing).
*/
private static final int T_JAVA = 3;
/**
* The OS repository subdirectory for Resource Signatures
*/
private static final int T_RES_SIG = 4;
/**
* The OS repository subdirectory for [resolved] resources
*/
private static final int T_RES_BINARY = 5;
/**
* The super class of Component.
*/
private static final String ROOT = "Root";
/**
* The OS repository subdirectories for each type.
*/
private static final String[] SUBDIR;
static
{
SUBDIR = new String[6];
SUBDIR[T_COMPONENT ] = "cdb";
SUBDIR[T_SIGNATURE ] = "jcs";
SUBDIR[T_CLASS ] = "classes";
SUBDIR[T_JAVA ] = "java";
SUBDIR[T_RES_SIG ] = "resource";
SUBDIR[T_RES_BINARY ] = "classes";
}
/**
* The OS repository file extension for Component Definition Binaries.
*
* Note, the code currently assumes that the suffixes are all
* lower case.
*/
private static final String[] SUFFIX;
static
{
SUFFIX = new String[6];
SUFFIX[T_COMPONENT ] = ".cdb";
SUFFIX[T_SIGNATURE ] = ".jcs";
SUFFIX[T_CLASS ] = ".class";
SUFFIX[T_JAVA ] = ".java";
SUFFIX[T_RES_SIG ] = "";
SUFFIX[T_RES_BINARY ] = "";
}
/**
* The OS repository root path.
*/
private File m_path;
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy