Update of /cvsroot/metamorphosis/ruper2/src/java/core/org/krysalis/ruper2/files
In directory sc8-pr-cvs1:/tmp/cvs-serv30481/src/java/core/org/krysalis/ruper2/files
Added Files:
TypeTable.java ResourceFilenameAnalyzer.java
DefaultResourceFilenameAnalyzer.java ExtensionTable.java
Log Message:
Avoid clash with existing Ruper...
--- NEW FILE: TypeTable.java ---
/*
* Created on Sep 3, 2003
*/
package org.krysalis.ruper2.files;
import java.util.HashMap;
import java.util.Map;
/**
* @author arb_jack
*/
public class TypeTable {
private Map m_typeMap = new HashMap();
class TypeEntry {
String m_type;
String m_description;
TypeEntry(String type, String description) {
m_type = type;
m_description = description;
}
}
public boolean hasType(String extension) {
return m_typeMap.containsKey(extension);
}
public static TypeTable TYPE_TABLE = null;
static {
TYPE_TABLE = new TypeTable();
TYPE_TABLE.register("-src", "Source Code");
TYPE_TABLE.register("-docs", "Documentation");
}
private void register(String type, String desc) {
registerEntry(new TypeTable.TypeEntry(type, desc));
}
private void registerEntry(TypeEntry entry) {
m_typeMap.put(entry.m_type, entry);
}
private TypeEntry getEntryByType(String type) {
return (TypeEntry) m_typeMap.get(type);
}
}
--- NEW FILE: ResourceFilenameAnalyzer.java ---
/*
* Created on Sep 3, 2003
*/
package org.krysalis.ruper2.files;
import java.util.List;
import org.krysalis.ruper2.RuperException;
import org.krysalis.ruper2.resource.Resource;
/**
* @author arb_jack
*/
public interface ResourceFilenameAnalyzer {
List determineResources(List entityList) throws RuperException;
Resource determineResource(Object entity) throws RuperException;
}
--- NEW FILE: DefaultResourceFilenameAnalyzer.java ---
/*
* Created on Sep 3, 2003
*/
package org.krysalis.ruper2.files;
import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
import org.krysalis.ruper2.RuperException;
import org.krysalis.ruper2.RuperRuntimeException;
import org.krysalis.ruper2.log.Logger;
import org.krysalis.ruper2.protocols.VirtualResourceLocator;
import org.krysalis.ruper2.resource.Resource;
import org.krysalis.ruper2.resource.ResourceType;
import org.krysalis.ruper2.util.text.MessageConstants;
import org.krysalis.ruper2.util.text.Messages;
import org.krysalis.version.VersionException;
import org.krysalis.version.impl.KrysalisVersion;
import org.krysalis.version.impl.data.ReleaseLevel;
/**
* @author arb_jack
*/
public class DefaultResourceFilenameAnalyzer
implements ResourceFilenameAnalyzer {
private VirtualResourceLocator m_base = null;
public DefaultResourceFilenameAnalyzer(VirtualResourceLocator base) {
m_base = base;
}
//
// Working Area. Since we aren't sure what order the resources
// come in, and we might combine multiple inputs to make up the
// attributes of a single resource (e.g. attach the MD5 location
// to the owning resource)...
//
class ResourceWorkingStore {
private List m_list = new ArrayList();
private Map m_map = new HashMap();
boolean contains(Resource resource) {
return m_map.containsKey(resource);
}
void addResource(Resource resource) {
String id = resource.getIdentifier().getId();
// Meant to look first...
if (m_map.containsKey(resource))
throw new RuperRuntimeException(
"Duplicate Resource in working store: " + id);
m_map.put(resource, resource);
m_list.add(resource);
}
Resource getResource(Resource resource) {
return (Resource) m_map.get(resource);
}
List getCompletedList() {
// :TODO: Only those "complete", e.g. not an MD5 w/o the real one...
return m_list;
}
}
public List determineResources(List entityList) throws RuperException {
ResourceWorkingStore store =
new DefaultResourceFilenameAnalyzer.ResourceWorkingStore();
for (Iterator i = entityList.iterator(); i.hasNext();) {
Object entity = i.next();
try {
//
// Understood objects
//
if (entity instanceof String)
processString(
(String) entity,
new VirtualResourceLocator(m_base, (String) entity),
store);
else if (entity instanceof VirtualResourceLocator)
processVRL((VirtualResourceLocator) entity, store);
else if (entity instanceof File)
processFile((File) entity, store);
//
// Hmm VFS? How utilize yet be separate? Maybe String...
//
else {
Logger.getLog().error(
Messages.getString(
MessageConstants.WRONG_TYPE,
entity));
}
}
catch (RuperException re) {
//:TODO: log/context/listeners...
}
}
return store.getCompletedList();
}
public Resource determineResource(Object entity) throws RuperException {
ResourceWorkingStore store =
new DefaultResourceFilenameAnalyzer.ResourceWorkingStore();
try {
//
// Understood objects
//
if (entity instanceof String)
processString(
(String) entity,
new VirtualResourceLocator(m_base, (String) entity),
store);
else if (entity instanceof VirtualResourceLocator)
processVRL((VirtualResourceLocator) entity, store);
else if (entity instanceof File)
processFile((File) entity, store);
//
// Hmm VFS? How utilize yet be separate? Maybe String...
//
else {
Logger.getLog().error(
Messages.getString(MessageConstants.WRONG_TYPE, entity));
}
}
catch (RuperException re) {
Logger.getLog().error(
Messages.getString(
MessageConstants.GENERAL_EXCEPTION2,
new Object[] { entity, re.getLocalizedMessage()}),
re);
}
return (Resource) store.getCompletedList().get(0);
}
void processVRL(
VirtualResourceLocator resourceVRL,
ResourceWorkingStore store)
throws RuperException {
String name = resourceVRL.toExternalForm();
int sepPosn = name.lastIndexOf('/');
String baseName = (-1 == sepPosn) ? name : name.substring(sepPosn + 1);
processString(baseName, resourceVRL, store);
}
void processFile(File resource, ResourceWorkingStore store)
throws RuperException {
String name = resource.getName().toString();
int sepPosn = name.lastIndexOf(File.pathSeparator);
String baseName = (-1 == sepPosn) ? name : name.substring(sepPosn + 1);
processString(baseName, new VirtualResourceLocator(resource), store);
}
//
// HACK HACK HACK -- to get us started. Will evolve into a
// whole configurable parsing sub-system
//
void processString(
String resourceName,
VirtualResourceLocator location,
ResourceWorkingStore store)
throws RuperException {
Logger.getLog().debug(
Messages.getString(
MessageConstants.PROCESS,
new Object[] { resourceName, location }));
// Parts...
String extension = null;
String type = null;
String version = null;
String name = null;
// Determine the extension
extension = extractExtension(resourceName);
// Remainder is name-version-type
String remainder =
resourceName.substring(
0,
(resourceName.length() - (extension.length() + 1)));
//
// Type is anything after the last - or _ so long as
// it doesn't start with a digit (i.e. is the version)
// .. and so long as it isn't a release level
//
int typePosn = findLastSeparator(remainder);
if (-1 != typePosn) {
if (!Character.isDigit(remainder.charAt(typePosn + 1))) {
type = remainder.substring(typePosn + 1);
if (!ReleaseLevel
.UNSET
.equals(ReleaseLevel.getFromStringFailSafe(type))) {
type = null; // ResourceType.JAVA_BINARY;
}
else {
//
// What is left is name/version
//
remainder = remainder.substring(0, typePosn);
}
}
}
//
// Version is anything after the first - or _ followed
// by a Digit
//
int versionPosn = findSeparatorBeforeVersionNumbers(remainder);
if (-1 != versionPosn) {
version = remainder.substring(versionPosn + 1, remainder.length());
name = remainder.substring(0, versionPosn);
}
else
name = remainder;
Logger.getLog().debug(
Messages.getString(
MessageConstants.EXTRACTED,
new Object[] { name, version, type, extension }));
try {
Resource temp =
new Resource(
name,
(null == version ? null : new KrysalisVersion(version)),
ResourceType.getFromString(type),
resourceName,
location);
//:TODO: Could be written better
if (!store.contains(temp)) {
store.addResource(temp);
}
else {
//:TODO: Fix
Logger.getLog().debug(
Messages.getString(
MessageConstants.MERGE,
new Object[] { resourceName, location, temp }));
}
}
catch (VersionException ve) {
Logger.getLog().error(
Messages.getString(
MessageConstants.GENERAL_EXCEPTION3,
new Object[] {
resourceName,
location,
ve.getLocalizedMessage()}),
ve);
}
}
int findLastSeparator(String input) {
return findLastSeparator(input, input.length());
}
int findLastSeparator(String input, int start) {
int dashPosn = input.lastIndexOf('-', start);
int underscorePosn = input.lastIndexOf('_', start);
return (dashPosn >= underscorePosn) ? dashPosn : underscorePosn;
}
int findSeparator(String input) {
return findSeparator(input, 0);
}
int findSeparator(String input, int start) {
int dashPosn = input.indexOf('-', start);
int underscorePosn = input.indexOf('_', start);
return (dashPosn >= underscorePosn) ? dashPosn : underscorePosn;
}
int findSeparatorBeforeVersionNumbers(String input) {
//
// Search for xxx-[0-9] (where xxx may have -[A-Za-z...etc.]
// If not found, can't continue...
//
int separatorPosn = -1;
int currentPosn = 0;
do {
int posn = findSeparator(input, currentPosn);
// Found and not last character
if ((-1 != posn) && (posn < input.length())) {
int numPosn = posn + 1;
if (Character.isDigit(input.charAt(numPosn))) {
separatorPosn = posn;
}
else
currentPosn = numPosn;
}
else {
//
// Can't process
//
break;
}
}
while (-1 == separatorPosn);
return separatorPosn;
}
String extractExtension(String resourceName) throws RuperException {
// Extract extensions
List probableExtns = extractProbableExtensions(resourceName);
// Attempt to match extensions, if not accept it is unknown
// and take "biggest"
String extension = null;
for (Iterator i = probableExtns.iterator();
i.hasNext() && (null == extension);
) {
String extn = (String) i.next();
if (ExtensionTable.EXTENSION_TABLE.hasExtension(extn))
extension = extn;
}
// If not found, pick "largest" = first.
if (null == extension)
if (0 == probableExtns.size())
throw new RuperException(
"Unable to extract extension from [" + resourceName + "]");
extension = (String) probableExtns.get(0);
return extension;
}
//
// Return a list (sorted by largest number of periods)
//
List extractProbableExtensions(String name) {
// Get period separated tokens in reverse order
List tokenList = new ArrayList();
StringTokenizer tokens = new StringTokenizer(name, ".");
for (; tokens.hasMoreTokens();) {
tokenList.add(tokens.nextToken());
}
Collections.reverse(tokenList);
// Build Results
List extensionChoices = new ArrayList();
String extension = null;
for (Iterator i = tokenList.iterator(); i.hasNext();) {
String token = (String) i.next();
if (null == extension)
extension = token;
else
extension = token + "." + extension;
// If not starts with a number
// and not the whole thing ...
if (!Character.isDigit(token.charAt(0)) && i.hasNext()) {
extensionChoices.add(extension);
}
}
Collections.reverse(extensionChoices);
return extensionChoices;
}
}
--- NEW FILE: ExtensionTable.java ---
/*
* Created on Sep 3, 2003
*/
package org.krysalis.ruper2.files;
import java.util.HashMap;
import java.util.Map;
/**
* @author arb_jack
*/
public class ExtensionTable {
private Map m_extnMap = new HashMap();
private Map m_mimeMap = new HashMap();
class ExtensionEntry {
String m_extn;
String m_description;
String m_mime;
ExtensionEntry(String extn, String description, String mime) {
m_extn = extn;
m_description = description;
m_mime = mime;
}
}
public boolean hasExtension(String extension)
{
return m_extnMap.containsKey(extension);
}
public static ExtensionTable EXTENSION_TABLE = null;
static {
EXTENSION_TABLE = new ExtensionTable();
EXTENSION_TABLE.register("jar", "Java Archive", "TODO");
EXTENSION_TABLE.register("tar", "Tape Archive", "TODO");
EXTENSION_TABLE.register("zip", "ZIP Archive", "TODO");
EXTENSION_TABLE.register("tar.Z", "Compressed Tape Archive", "TODO");
}
private void register(String extn, String desc, String mime) {
registerEntry(new ExtensionTable.ExtensionEntry(extn, desc, mime));
}
private void registerEntry(ExtensionEntry entry) {
m_extnMap.put(entry.m_extn, entry);
m_mimeMap.put(entry.m_mime, entry);
}
private ExtensionEntry getEntryByExtension(String extn) {
return (ExtensionEntry) m_extnMap.get(extn);
}
private ExtensionEntry getEntryByMime(String mime) {
return (ExtensionEntry) m_mimeMap.get(mime);
}
}
-------------------------------------------------------
This sf.net email is sponsored by:ThinkGeek
Welcome to geek heaven.
http://thinkgeek.com/sf
lmpx.com only provides a reader for public news (NNTP) servers. It is not
affiliated with the servers or forums shown here and is not responsible for
the content of articles, which is written by their respective authors.