Mega Code Archive
A Map that stores the values in files within a directory
<![CDATA[
// package com.croftsoft.core.util.filemap;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.AbstractMap;
import java.util.AbstractSet;
import java.util.Iterator;
import java.util.Set;
/*********************************************************************
* A Map that stores the values in files within a directory.
*
* Uses filenames as the keys and InputStreams as the values.
*
* @see FilenameKeyGenerator
* @see java.util.AbstractMap
*
* @version 1999-04-03
* @author <a href="http://www.CroftSoft.com/">David Wallace Croft</a>
*********************************************************************/
public class FileMap extends AbstractMap
// ////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////
{
private File rootDirectory;
// ////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////
public static void main(String[] args)
// ////////////////////////////////////////////////////////////////////
{
System.out.println(test());
}
public static boolean test()
// ////////////////////////////////////////////////////////////////////
{
try {
String filename = "com.orbs.util.filemap.FileMap_test.tmp";
FileMap fileMap = new FileMap(new File("."));
fileMap.put(filename, new ByteArrayInputStream("Hello".getBytes()));
InputStream in = (InputStream) fileMap.get(filename);
int i;
while ((i = in.read()) > -1)
System.out.write(i);
in.close();
System.out.println("");
fileMap.remove(filename);
} catch (Exception ex) {
ex.printStackTrace();
return false;
}
return true;
}
// ////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////
public FileMap(File rootDirectory)
// ////////////////////////////////////////////////////////////////////
{
this.rootDirectory = rootDirectory;
}
// ////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////
public Set entrySet()
// ////////////////////////////////////////////////////////////////////
{
return new FileMapEntrySet(rootDirectory);
}
// synchronize?
public synchronized Object put(Object key, Object value)
// ////////////////////////////////////////////////////////////////////
{
File file = null;
BufferedOutputStream out = null;
InputStream in = null;
try {
String filename = (String) key;
file = new File(rootDirectory, filename);
out = new BufferedOutputStream(new FileOutputStream(file));
in = (InputStream) value;
int i;
while ((i = in.read()) > -1)
out.write(i);
} catch (IOException ioex) {
try {
out.close();
} catch (Exception ex) {
}
try {
file.delete();
} catch (Exception ex) {
}
throw new RuntimeException(ioex.getMessage());
} finally {
try {
in.close();
} catch (Exception ex) {
}
try {
out.close();
} catch (Exception ex) {
}
}
return null;
}
public synchronized Object remove(Object key)
// ////////////////////////////////////////////////////////////////////
{
String filename = (String) key;
File file = new File(rootDirectory, filename);
file.delete();
return null;
}
// ////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////
}
/*********************************************************************
* This Set is required for the AbstractMap implementation of FileMap.
*
* @see FileMap
* @see java.util.AbstractSet
*
* @version 1999-04-03
* @author <a href="http://www.CroftSoft.com/">David Wallace Croft</a>
*********************************************************************/
class FileMapEntrySet extends AbstractSet
// ////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////
{
private File rootDirectory;
// ////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////
public FileMapEntrySet(File rootDirectory)
// ////////////////////////////////////////////////////////////////////
{
this.rootDirectory = rootDirectory;
}
// ////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////
public Iterator iterator()
// ////////////////////////////////////////////////////////////////////
{
return new FileMapEntryIterator(rootDirectory);
}
public int size()
// ////////////////////////////////////////////////////////////////////
{
String[] files = rootDirectory.list();
if (files == null)
return 0;
return files.length;
}
// ////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////
}
/*********************************************************************
* This Iterator is required for the AbstractMap implementation of FileMap.
*
* @see FileMap
* @see java.util.AbstractSet
*
* @version 1999-04-03
* @author <a href="http://www.CroftSoft.com/">David Wallace Croft</a>
*********************************************************************/
class FileMapEntryIterator implements Iterator
// ////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////
{
private File rootDirectory;
private String[] files;
private int index = 0;
// ////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////
public FileMapEntryIterator(File rootDirectory)
// ////////////////////////////////////////////////////////////////////
{
this.rootDirectory = rootDirectory;
}
// ////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////
public synchronized boolean hasNext()
// ////////////////////////////////////////////////////////////////////
{
if (files == null)
files = rootDirectory.list();
if (files == null)
return false;
return (index < files.length);
}
public synchronized Object next()
// ////////////////////////////////////////////////////////////////////
{
if (files == null)
files = rootDirectory.list();
if (files == null)
return null;
if (index >= files.length)
return null;
return new FileMapEntry(rootDirectory, files[index++]);
}
public synchronized void remove()
// ////////////////////////////////////////////////////////////////////
{
if (files == null)
files = rootDirectory.list();
if (files == null)
return;
if (index >= files.length)
return;
new File(files[index]).delete();
}
// ////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////
}
/*********************************************************************
* This Map.Entry is required for the AbstractMap implementation of FileMap.
*
* @see FileMapEntryIterator
* @see FileMapEntrySet
* @see java.util.Map.Entry
*
* @version 1999-04-03
* @author <a href="http://www.CroftSoft.com/">David Wallace Croft</a>
*********************************************************************/
class FileMapEntry implements Map.Entry
// ////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////
{
private File rootDirectory;
private String filename;
// ////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////
public FileMapEntry(File rootDirectory, String filename)
// ////////////////////////////////////////////////////////////////////
{
this.rootDirectory = rootDirectory;
this.filename = filename;
}
// ////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////
public boolean equals(Object o)
// ////////////////////////////////////////////////////////////////////
{
if (o == null)
return false;
if (!o.getClass().equals(this.getClass()))
return false;
FileMapEntry other = (FileMapEntry) o;
if (!filename.equals(other.filename))
return false;
if (!rootDirectory.equals(other.rootDirectory))
return false;
if (hashCode() != other.hashCode())
return false;
return true;
}
public Object getKey()
// ////////////////////////////////////////////////////////////////////
{
return filename;
}
public Object getValue()
// ////////////////////////////////////////////////////////////////////
{
try {
return new FileInputStream(new File(rootDirectory, filename));
} catch (FileNotFoundException ex) {
return null;
}
}
public int hashCode()
// ////////////////////////////////////////////////////////////////////
{
return filename.hashCode();
}
public Object setValue(Object value)
// ////////////////////////////////////////////////////////////////////
{
throw new UnsupportedOperationException();
}
// ////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////
}
]]>