A Map that stores the values in files within a directory. : Map « Collections Data Structure « Java

1. Java
2. Collections Data Structure
3. Map

A Map that stores the values in files within a directory.

     
//     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();
  }

  // ////////////////////////////////////////////////////////////////////
  // ////////////////////////////////////////////////////////////////////
}

   
    
    
    
    
  

Related examples in the same category