/**
    * Copyright 2006 Steve Molloy
    * 
    * This file is part of OV4J.
    * 
    * OV4J is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as
    * published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
    * 
    * OV4J is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
   * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
   * 
   * You should have received a copy of the GNU General Public License along with OV4J; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
   * 
   */
  package org.ov4j.hessianImpl;
  
  import java.io.BufferedInputStream;
  import java.io.BufferedOutputStream;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.Serializable;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.ConcurrentModificationException;
  import java.util.Timer;
  import java.util.TimerTask;
  import java.util.TreeMap;
  import java.util.TreeSet;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  import org.ov4j.Config;
  import org.ov4j.IContainer;
  import org.ov4j.LoadThread;
  import org.ov4j.data.Item;
  import org.ov4j.data.Version;
  
  import com.caucho.hessian.io.HessianInput;
  import com.caucho.hessian.io.HessianOutput;
  
  /**
   * @author smolloy
   * 
   */
  public class Container<T extends Comparable<? super T> & Cloneable & Serializable, C extends Comparable<? super C>>
  	implements IContainer<T, C> {
  	/**
  	 * Logger for this class
  	 */
  	private static final Logger				logger					= Logger.getLogger(Container.class.getName());
  
  	/** Empty Comparable array. */
  	protected static final Comparable<?>[]	EMPTY_COMPARABLE_ARRAY	= new Comparable[0];
  
  	/** Folder name where to store items. */
  	protected static final String			ITEM_FOLDER				= "Items";
  
  	/** Folder name where to store versions. */
  	protected static final String			VERSION_FOLDER			= "_Versions";
  
  	/** Folder name where to store deleted ids. */
  	protected static final String			DELETED_FOLDER			= "Deleted";
  
  	/** Folder name where to store live data. */
  	protected static final String			LIVE_FOLDER				= "Live";
  
  	/** Folder name where to store work data not yet committed. */
  	protected static final String			WORK_FOLDER				= "Work";
  
  	/** FileFilter accepting folder files. */
  	protected static final DirFileFilter	FOLDER_FILTER			= new DirFileFilter();
  
  	/** Maximum number of items to cache. */
  	protected static final int				MAX_ITEM_CACHED			=
  																		Integer.parseInt(Config
  																			.getString("ov4j.hessian.cache.item.max"));
  
  	/** Maximum number of items to cache. */
  	protected static final int				MAX_LOADTHREAD			=
  																		Integer.parseInt(Config
  																			.getString("ov4j.hessian.loadthread.max"));
  
  	/** Maximum number of save retries when encountering ConcurrentModificationException. */
  	protected static final int				MAX_RETRY				=
  																		Integer.parseInt(Config
  																			.getString("ov4j.hessian.save.retry.max"));
  
  	/** Maximum amount of time an item will stay cached before being uncached automatically. */
  	protected static final long				MAX_CACHE_TIME			=
  																		Long.parseLong(Config
  																			.getString("ov4j.hessian.cache.time.max"));
  
  	/** Timer performing periodic saves. */
  	private static Timer					theTimer;
 
 	/**
 	 * Cancel and nullify the timer.
 	 */
 	private static void cancelTimer() {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "cancelTimer()", "start");
 		}
 
 		if (Container.theTimer != null) {
 			synchronized (Container.class) {
 				Container.theTimer.cancel();
 				Container.theTimer = null;
 			}
 		}
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "cancelTimer()", "end");
 		}
 	}
 
 	/**
 	 * Make sure a Timer is available.
 	 */
 	private static void ensureTimer() {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "ensureTimer()", "start");
 		}
 
 		if (Container.theTimer == null) {
 			synchronized (Container.class) {
 				Container.theTimer = new Timer();
 			}
 		}
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "ensureTimer()", "end");
 		}
 	}
 
 	/** Name of the DB. */
 	protected String					dbName;
 
 	/** Flag to indicate if DB is closed. */
 	protected boolean					closed;
 
 	/** Live items folder. */
 	protected File						liveItems;
 
 	/** Live deleted ids folder. */
 	protected File						liveDeleted;
 
 	/** Work items folder. */
 	protected File						workItems;
 
 	/** Work deleted ids folder. */
 	protected File						workDeleted;
 
 	/** Current live ID to filename Map. */
 	protected TreeMap<C, String>		idMap;
 
 	/** Current live filename to ID map. */
 	protected TreeMap<String, C>		revIdMap;
 
 	/** Current live deleted ID to filename Map. */
 	protected TreeMap<C, String>		deletedMap;
 
 	/** Current work ID to filename Map. */
 	protected TreeMap<C, String>		idMapWrk;
 
 	/** Current work filename to ID map. */
 	protected TreeMap<String, C>		revIdMapWrk;
 
 	/** Current work deleted ID to filename Map. */
 	protected TreeMap<C, String>		deletedMapWrk;
 
 	/** Recently loaded cache. */
 	protected TreeMap<C, Item<T, C>>	recentMap;
 
 	/** IDs kept in cache. */
 	protected ArrayList<C>				cachedIds;
 
 	/** Next filename to assign. */
 	protected long						counter				= -1L;
 
 	/** Lock used to avoid concurrent saving */
 	protected final Object				saveLock			= new Object();
 
 	/** List of pending tasks to execute. */
 	protected ArrayList<Runnable>		pendingTasks		= new ArrayList<Runnable>();
 
 	/** Flag for closing. */
 	protected boolean					closing				= false;
 
 	/** Flag for performing pending tasks. */
 	protected boolean					runningPendingTasks	= false;
 
 	/** Number of pending save or delete operations. */
 	protected int						pendingSaves		= 0;
 
 	/** Shutdown hook to make sure memory is saved to file when VM shuts down. */
 	protected transient Thread			hookThread;
 
 	/** Thread executing the background tasks. */
 	private transient Thread			taskExecutor;
 
 	/** Whether or not the task executor thread has already been started. */
 	private boolean						taskExecutorStarted	= false;
 
 	/**
 	 * Constructor.
 	 * 
 	 * @param dbName
 	 *            Name of the database.
 	 * @param delay
 	 *            Delay before the first save.
 	 * @param saveInterval
 	 *            Interval (in ms) between periodic replication to backup database.
 	 * @throws IOException
 	 */
 	public Container(final String dbName, final long delay, final long saveInterval) throws IOException {
 
 		this.dbName = dbName;
 		closed = false;
 
 		// Make sure base folder exists
 		final File base = new File(dbName);
 		base.mkdirs();
 
 		// Build live tree
 		final File live = new File(base, Container.LIVE_FOLDER);
 		live.mkdir();
 		liveItems = new File(live, Container.ITEM_FOLDER);
 		liveItems.mkdir();
 		liveDeleted = new File(live, Container.DELETED_FOLDER);
 		liveDeleted.mkdir();
 
 		// Build work tree
 		final File work = new File(base, Container.WORK_FOLDER);
 		work.mkdir();
 		workItems = new File(work, Container.ITEM_FOLDER);
 		workItems.mkdir();
 		workDeleted = new File(work, Container.DELETED_FOLDER);
 		workDeleted.mkdir();
 
 		// Create and populate memory maps.
 		cachedIds = new ArrayList<C>();
 		recentMap = new TreeMap<C, Item<T, C>>();
 		idMap = new TreeMap<C, String>();
 		revIdMap = new TreeMap<String, C>();
 		deletedMap = new TreeMap<C, String>();
 		idMapWrk = new TreeMap<C, String>();
 		revIdMapWrk = new TreeMap<String, C>();
 		deletedMapWrk = new TreeMap<C, String>();
 		populateIdMap();
 		populateDeletedMap();
 		final TimerTask backupTask = new TimerTask() {
 			public void run() {
 				while (!Config.checkMemory()) {
 					try {
 						Thread.sleep(30000);
 					} catch (InterruptedException e) {
 						if (Container.logger.isLoggable(Level.FINE)) {
 							Container.logger.logp(Level.FINE, "Container", "BackupTask$TimerTask.run()",
 								"exception ignored", e);
 						}
 					}
 				}
 
 				backup();
 			}
 		};
 		Container.ensureTimer();
 		if (delay > -1 && saveInterval > -1) {
 			Container.theTimer.scheduleAtFixedRate(backupTask, delay, saveInterval);
 		}
 		initTaskExecutor();
 		final Runnable saveHook = new Runnable() {
 			public void run() {
 				try {
 					close(false);
 				} catch (IOException e) {
 					if (Container.logger.isLoggable(Level.FINE)) {
 						Container.logger.logp(Level.FINE, "Container", "SaveHook$Runnable.run()", "exception ignored",
 							e);
 					}
 				}
 			}
 		};
 		hookThread = new Thread(saveHook);
 		Runtime.getRuntime().addShutdownHook(hookThread);
 	}
 
 	/**
 	 * Backup the data and ID map databases.
 	 * 
 	 */
 	protected void backup() {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "backup()", "start");
 		}
 
 		if (!isClosed()) {
 			try {
 				commit();
 				final Container<T, C> bak = new Container<T, C>(dbName + ".bak", -1, -1);
 				bak.clear();
 				bak.duplicate(this);
 				bak.close();
 			} catch (final Throwable ex) {
 				if (Container.logger.isLoggable(Level.FINE)) {
 					Container.logger.logp(Level.FINE, "Container", "backup()", "exception ignored", ex);
 				}
 			}
 		}
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "backup()", "end");
 		}
 	}
 
 	/**
 	 * @throws IOException
 	 * @see org.ov4j.IContainer#batchDelete(org.ov4j.data.Item<T>[], boolean)
 	 */
 	public void batchDelete(final Item<T, C>[] items, final boolean keepTrack) throws IOException {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "batchDelete(Item<T,C>[]=" + Arrays.toString(items) + ", boolean="
 				+ keepTrack + ")", "start");
 		}
 
 		if (items != null && items.length > 0) {
 			for (int i = 0; i < items.length; i++) {
 				delete(items[i], keepTrack);
 			}
 		}
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "batchDelete(Item<T,C>[]=" + Arrays.toString(items) + ", boolean="
 				+ keepTrack + ")", "end");
 		}
 	}
 
 	/**
 	 * @see org.ov4j.IContainer#batchMerge(java.lang.Comparable[])
 	 */
 	public void batchMerge(final C[] ids) throws IOException {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "batchMerge(C[]=" + Arrays.toString(ids) + ")", "start");
 		}
 
 		final Runnable t = new Runnable() {
 			public void run() {
 				synchronized (saveLock) {
 					try {
 						ArrayList<Item<T, C>> res = new ArrayList<Item<T, C>>();
 						Item<T, C>[] items = load(ids, true);
 						Collections.addAll(res, items);
 						Collections.sort(res, new Comparator<Item<T, C>>() {
 							public int compare(Item<T, C> it1, Item<T, C> it2) {
 								if (it1 == null) {
 									return (it2 == null) ? 0 : -1;
 								}
 
 								if (it2 == null) {
 									return 1;
 								}
 
 								return (it1.getId().compareTo(it2.getId()));
 							}
 						});
 						ArrayList<Item<T, C>> mergedList = new ArrayList<Item<T, C>>();
 						ArrayList<Item<T, C>> deletedList = new ArrayList<Item<T, C>>();
 						C lastId = null;
 						long lastTStamp = -1;
 						for (int i = 0; i < res.size(); i++) {
 							Item<T, C> current = res.get(i);
 							if (lastId == null || lastId.compareTo(current.getId()) != 0) {
 								mergedList.add(0, current);
 								lastId = current.getId();
 								lastTStamp = current.getModificationStamp();
 							} else {
 								if (current.getModificationStamp() > lastTStamp) {
 									deletedList.add(0, mergedList.remove(0));
 								} else {
 									deletedList.add(current);
 								}
 							}
 						}
 						batchSave(mergedList.toArray((Item<T, C>[]) Item.EMPTY_ARRAY), false);
 						batchDelete(deletedList.toArray((Item<T, C>[]) Item.EMPTY_ARRAY), false);
 					} catch (IOException e) {
 						if (Container.logger.isLoggable(Level.FINE)) {
 							Container.logger.logp(Level.FINE, "Container", "batchMerge(C[]=" + Arrays.toString(ids)
 								+ ")$Runnable.run()", "exception ignored", e);
 						}
 					}
 				}
 				synchronized (pendingTasks) {
 					pendingSaves--;
 				}
 			}
 		};
 		synchronized (pendingTasks) {
 			pendingSaves++;
 			pendingTasks.add(t);
 		}
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "batchMerge(C[]=" + Arrays.toString(ids) + ")", "end");
 		}
 	}
 
 	/**
 	 * @see org.ov4j.IContainer#batchSave(org.ov4j.data.Item<T>[], boolean)
 	 */
 	public void batchSave(final Item<T, C>[] items, final boolean abortOnDuplicate) throws IOException {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "batchSave(Item<T,C>[]=" + Arrays.toString(items) + ", boolean="
 				+ abortOnDuplicate + ")", "start");
 		}
 
 		if (items != null && items.length > 0) {
 			if (abortOnDuplicate) {
 				for (int i = 0; i < items.length; i++) {
 					if (inUse(items[i].getId())) {
 						if (Container.logger.isLoggable(Level.FINER)) {
 							Container.logger.exiting("Container", "batchSave(Item<T,C>[]=" + Arrays.toString(items)
 								+ ", boolean=" + abortOnDuplicate + ")", "end");
 						}
 						return;
 					}
 				}
 			}
 			final ArrayList<Item<T, C>> list = new ArrayList<Item<T, C>>();
 			Collections.addAll(list, items);
 			while (list.size() > 0) {
 				save(list.remove(0));
 			}
 		}
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "batchSave(Item<T,C>[]=" + Arrays.toString(items) + ", boolean="
 				+ abortOnDuplicate + ")", "end");
 		}
 	}
 
 	/**
 	 * Add an item to the cache.
 	 * 
 	 * @param id
 	 *            ID of the item.
 	 * @param it
 	 *            Item to cache.
 	 */
 	protected void cacheItem(final C id, final Item<T, C> it) {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "cacheItem(C=" + id + ", Item<T,C>=" + it + ")", "start");
 		}
 
 		synchronized (recentMap) {
 			if (cachedIds.size() > Container.MAX_ITEM_CACHED || !Config.enoughFree()) {
 				final Comparable<?> uncache = cachedIds.remove(0);
 				recentMap.remove(uncache);
 			}
 			recentMap.put(id, it);
 			cachedIds.add(id);
 		}
 		final TimerTask t = new TimerTask() {
 			public void run() {
 				uncacheItem(id);
 			}
 		};
 		Container.ensureTimer();
 		Container.theTimer.schedule(t, Container.MAX_CACHE_TIME);
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "cacheItem(C=" + id + ", Item<T,C>=" + it + ")", "end");
 		}
 	}
 
 	/**
 	 * @see org.ov4j.IContainer#clear()
 	 */
 	public void clear() {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "clear()", "start");
 		}
 
 		rollback();
 		cachedIds.clear();
 		recentMap.clear();
 		idMap.clear();
 		deletedMap.clear();
 		File[] files = liveItems.listFiles(Container.FOLDER_FILTER);
 		for (int i = 0; i < files.length; i++) {
 			final File[] subFiles = files[i].listFiles();
 			for (int j = 0; j < subFiles.length; j++) {
 				subFiles[j].delete();
 			}
 		}
 		files = liveItems.listFiles();
 		for (int i = 0; i < files.length; i++) {
 			files[i].delete();
 		}
 		files = liveDeleted.listFiles();
 		for (int i = 0; i < files.length; i++) {
 			files[i].delete();
 		}
 		Config.checkMemory();
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "clear()", "end");
 		}
 	}
 
 	/**
 	 * @throws IOException
 	 * @see org.ov4j.IContainer#close()
 	 */
 	public synchronized void close() throws IOException {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "close()", "start");
 		}
 
 		close(true);
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "close()", "end");
 		}
 	}
 
 	/**
 	 * @throws IOException
 	 * @see org.ov4j.IContainer#close()
 	 */
 	public void close(final boolean removeHook) throws IOException {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "close(boolean=" + removeHook + ")", "start");
 		}
 
 		waitForPendingTasks();
 		closing = true;
 		if (removeHook && hookThread != null) {
 			Runtime.getRuntime().removeShutdownHook(hookThread);
 		}
 		if (pendingTasks != null && pendingTasks.size() > 0) {
 			runningPendingTasks = true;
 			Runnable[] tasks = null;
 			synchronized (pendingTasks) {
 				tasks = pendingTasks.toArray(new Runnable[0]);
 				pendingTasks.clear();
 			}
 			for (int i = 0; i < tasks.length; i++) {
 				tasks[i].run();
 			}
 			runningPendingTasks = false;
 		}
 		Container.cancelTimer();
 		Config.checkMemory();
 
 		closed = true;
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "close(boolean=" + removeHook + ")", "end");
 		}
 	}
 
 	/**
 	 * @see org.ov4j.IContainer#commit()
 	 */
 	public void commit() {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "commit()", "start");
 		}
 
 		waitForPendingTasks();
 		synchronized (saveLock) {
 			if (!deletedMapWrk.isEmpty()) {
 				final C[] ids = deletedMapWrk.keySet().toArray((C[]) Container.EMPTY_COMPARABLE_ARRAY);
 				for (int i = 0; i < ids.length; i++) {
 					final String filename = deletedMapWrk.remove(ids[i]);
 					idMap.remove(ids[i]);
 					revIdMap.remove(filename);
 					deletedMap.put(ids[i], filename);
 					final File wrkFile = new File(workDeleted, filename);
 					final File liveFile = new File(liveDeleted, filename);
 					if (liveFile.exists()) {
 						liveFile.delete();
 					}
 					wrkFile.renameTo(liveFile);
 					final File liveItem = new File(liveItems, filename);
 					liveItem.delete();
 					final File verDir = new File(liveItems, filename + Container.VERSION_FOLDER);
 					final File[] liveVers = verDir.listFiles();
 					if (liveVers != null && liveVers.length > 0) {
 						for (int j = 0; j < liveVers.length; j++) {
 							liveVers[j].delete();
 						}
 					}
 					verDir.delete();
 				}
 			}
 			if (!idMapWrk.isEmpty()) {
 				final C[] ids = idMapWrk.keySet().toArray((C[]) Container.EMPTY_COMPARABLE_ARRAY);
 				for (int i = 0; i < ids.length; i++) {
 					final String filename = idMapWrk.remove(ids[i]);
 					idMap.put(ids[i], filename);
 					revIdMap.put(filename, ids[i]);
 					final File liveVerDir = new File(liveItems, filename + Container.VERSION_FOLDER);
 					if (liveVerDir.exists()) {
 						final File[] files = liveVerDir.listFiles();
 						if (files != null && files.length > 0) {
 							for (int j = 0; j < files.length; j++) {
 								files[j].delete();
 							}
 						}
 						liveVerDir.delete();
 					}
 					final File workVerDir = new File(workItems, filename + Container.VERSION_FOLDER);
 					if (workVerDir.exists()) {
 						workVerDir.renameTo(liveVerDir);
 					}
 					final File live = new File(liveItems, filename);
 					if (live.exists()) {
 						live.delete();
 					}
 					final File work = new File(workItems, filename);
 					if (work.exists()) {
 						work.renameTo(live);
 					}
 				}
 			}
 		}
 		Config.checkMemory();
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "commit()", "end");
 		}
 	}
 
 	/**
 	 * @throws IOException
 	 * @see org.ov4j.IContainer#delete(org.ov4j.data.Item, boolean)
 	 */
 	public void delete(final Item<T, C> it, final boolean keepTrack) throws IOException {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "delete(Item<T,C>=" + it + ", boolean=" + keepTrack + ")", "start");
 		}
 
 		uncacheItem(it.getId());
 		final Runnable t = new Runnable() {
 			public void run() {
 				synchronized (saveLock) {
 					try {
 						if (it != null && inUse(it.getId())) {
 							String filename = idMap.get(it.getId());
 							idMapWrk.remove(it.getId());
 							revIdMapWrk.remove(filename);
 							if (keepTrack) {
 								deletedMapWrk.put(it.getId(), filename);
 								File file = new File(workDeleted, filename);
 								BufferedOutputStream fOut = new BufferedOutputStream(new FileOutputStream(file));
 								HessianOutput out = new HessianOutput(fOut);
 								out.writeObject(it.getId());
 								fOut.close();
 							}
 						}
 					} catch (IOException e) {
 						if (Container.logger.isLoggable(Level.FINE)) {
 							Container.logger.logp(Level.FINE, "Container", "delete(Item<T,C>=" + it + ", boolean="
 								+ keepTrack + ")$Runnable.run()", "exception ignored", e);
 						}
 					}
 				}
 				synchronized (pendingTasks) {
 					pendingSaves--;
 				}
 			}
 		};
 		synchronized (pendingTasks) {
 			pendingSaves++;
 			pendingTasks.add(t);
 		}
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "delete(Item<T,C>=" + it + ", boolean=" + keepTrack + ")", "end");
 		}
 	}
 
 	/**
 	 * @see org.ov4j.IContainer#deletedIds()
 	 */
 	public C[] deletedIds() {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "deletedIds()", "start");
 		}
 
 		final C[] returnComparableArray = deletedMap.keySet().toArray((C[]) Container.EMPTY_COMPARABLE_ARRAY);
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "deletedIds()", "end - return value="
 				+ Arrays.toString(returnComparableArray));
 		}
 		return returnComparableArray;
 	}
 
 	/**
 	 * @throws IOException
 	 * @see org.ov4j.IContainer#deletedIdsSince(long)
 	 */
 	public C[] deletedIdsSince(final long timestamp) throws IOException {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "deletedIdsSince(long=" + timestamp + ")", "start");
 		}
 
 		final File[] files = liveDeleted.listFiles(new TStampFileFilter(timestamp));
 		final C[] ids = (C[]) new Comparable[files.length];
 		for (int i = 0; i < files.length; i++) {
 			ids[i] = filenameToId(files[i].getName());
 		}
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "deletedIdsSince(long=" + timestamp + ")", "end - return value="
 				+ Arrays.toString(ids));
 		}
 		return ids;
 	}
 
 	/**
 	 * Converts the given IContainer into an hessian implementation.
 	 * 
 	 * @param cont
 	 *            IContainer to convert.
 	 * @throws IOException
 	 */
 	public void duplicate(final IContainer<T, C> cont) throws IOException {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "duplicate(IContainer<T,C>=" + cont + ")", "start");
 		}
 
 		final C[] ids = cont.listModifiedSince(-1);
 		if (ids != null) {
 			for (int startIdx = 0; startIdx < ids.length; startIdx += Container.MAX_LOADTHREAD) {
 				final C[] buf = (C[]) new Comparable[Math.min(Container.MAX_LOADTHREAD, (ids.length - startIdx))];
 				System.arraycopy(ids, startIdx, buf, 0, buf.length);
 				batchSave(cont.load(buf, true), false);
 			}
 		}
 		commit();
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "duplicate(IContainer<T,C>=" + cont + ")", "end");
 		}
 	}
 
 	/**
 	 * Generate ID from filename.
 	 * 
 	 * @param filename
 	 *            Filename from which to generate ID.
 	 * @return ID generated
 	 * @throws IOException
 	 */
 	protected C filenameToId(final String filename) throws IOException {
 		if (Container.logger.isLoggable(Level.FINEST)) {
 			Container.logger.entering("Container", "filenameToId(String=" + filename + ")", "start");
 		}
 
 		final C returnComparable = revIdMap.get(filename);
 
 		if (Container.logger.isLoggable(Level.FINEST)) {
 			Container.logger.exiting("Container", "filenameToId(String=" + filename + ")", "end - return value="
 				+ returnComparable);
 		}
 		return returnComparable;
 	}
 
 	/**
 	 * Generate filename for given ID.
 	 * 
 	 * @param id
 	 *            ID for which to generate a filename.
 	 * @return Filename generated.
 	 * @throws IOException
 	 */
 	protected String idToFilename(final C id) throws IOException {
 		if (Container.logger.isLoggable(Level.FINEST)) {
 			Container.logger.entering("Container", "idToFilename(C=" + id + ")", "start");
 		}
 
 		if (idMap.containsKey(id)) {
 			final String returnString2 = idMap.get(id);
 
 			if (Container.logger.isLoggable(Level.FINEST)) {
 				Container.logger.exiting("Container", "idToFilename(C=" + id + ")", "end - return value="
 					+ returnString2);
 			}
 			return returnString2;
 		}
 
 		while (new File(liveItems, String.valueOf(++counter)).exists()) {
 			;
 		}
 		while (new File(workItems, String.valueOf(++counter)).exists()) {
 			;
 		}
 
 		final String returnString = String.valueOf(counter);
 
 		if (Container.logger.isLoggable(Level.FINEST)) {
 			Container.logger.exiting("Container", "idToFilename(C=" + id + ")", "end - return value=" + returnString);
 		}
 		return returnString;
 	}
 
 	/**
 	 * Initializ task executor thread.
 	 */
 	private void initTaskExecutor() {
 		if (taskExecutor == null) {
 			taskExecutor = new Thread() {
 				public void run() {
 					while (!closing) {
 						if (pendingTasks != null && pendingTasks.size() > 0) {
 							runningPendingTasks = true;
 							Runnable[] tasks = null;
 							synchronized (pendingTasks) {
 								tasks = pendingTasks.toArray(new Runnable[0]);
 								pendingTasks.clear();
 							}
 							for (int i = 0; i < tasks.length; i++) {
 								tasks[i].run();
 							}
 							runningPendingTasks = false;
 						}
 						try {
 							Thread.sleep(10);
 						} catch (final InterruptedException e) {
 							if (Container.logger.isLoggable(Level.FINE)) {
 								Container.logger.logp(Level.FINE, "Container", "TaskExecutor$Thread.run()",
 									"exception ignored", e);
 							}
 						}
 					}
 				}
 			};
 		}
 	}
 
 	/**
 	 * @see org.ov4j.IContainer#inUse(java.lang.Comparable)
 	 */
 	public boolean inUse(final C id) {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "inUse(C=" + id + ")", "start");
 		}
 
 		final boolean returnboolean = idMap.containsKey(id);
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "inUse(C=" + id + ")", "end - return value=" + returnboolean);
 		}
 		return returnboolean;
 	}
 
 	/**
 	 * @see org.ov4j.IContainer#isClosed()
 	 */
 	public boolean isClosed() {
 		return closed;
 	}
 
 	/**
 	 * @see org.ov4j.IContainer#listModifiedSince(long)
 	 */
 	public C[] listModifiedSince(final long timestamp) throws IOException {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "listModifiedSince(long=" + timestamp + ")", "start");
 		}
 
 		final File[] files = liveItems.listFiles(new TStampFileFilter(timestamp));
 		final C[] ids = (C[]) new Comparable[files.length];
 		for (int i = 0; i < files.length; i++) {
 			ids[i] = filenameToId(files[i].getName());
 		}
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "listModifiedSince(long=" + timestamp + ")", "end - return value="
 				+ Arrays.toString(ids));
 		}
 		return ids;
 	}
 
 	/**
 	 * @see org.ov4j.IContainer#load(java.lang.Comparable, boolean)
 	 */
 	@Override
 	public Item<T, C> load(final C id, final boolean allVersions) throws IOException {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "load(C=" + id + ", boolean=" + allVersions + ")", "start");
 		}
 
 		if (id == null) {
 			if (Container.logger.isLoggable(Level.FINER)) {
 				Container.logger.exiting("Container", "load(C=null, boolean=" + allVersions + ")",
 					"end - return value=null");
 			}
 			return null;
 		}
 
 		Item<T, C> it = null;
 		final String filename = idMap.get(id);
 		if (recentMap.containsKey(id)) {
 			it = recentMap.get(id);
 		}
 
 		if (it == null && idMap.containsKey(id)) {
 			final File tst = new File(liveItems, filename);
 			if (tst.exists()) {
 				final BufferedInputStream fIn = new BufferedInputStream(new FileInputStream(tst));
 				final HessianInput in = new HessianInput(fIn);
 				it = (Item<T, C>) in.readObject();
 				fIn.close();
 			}
 		}
 		if (it != null && allVersions) {
 			final Version<?>[] vers = it.getVersions();
 			if (vers == null || vers.length < 1) {
 				final File verFolder = new File(liveItems, filename + Container.VERSION_FOLDER);
 				if (verFolder.exists()) {
 					final File[] verFiles = verFolder.listFiles();
 					final TreeSet<Version<?>> verTree = new TreeSet<Version<?>>();
 					for (int i = 0; i < verFiles.length; i++) {
 						final BufferedInputStream fIn = new BufferedInputStream(new FileInputStream(verFiles[i]));
 						final HessianInput verIn = new HessianInput(fIn);
 						verTree.add((Version<T>) verIn.readObject());
 						fIn.close();
 					}
 					it.versions((Version<T>[]) verTree.toArray(Version.EMPTY_ARRAY));
 				}
 			}
 		}
 		if (it != null) {
 			cacheItem(id, it);
 			try {
 				it = it.clone();
 			} catch (final CloneNotSupportedException e) {
 				if (Container.logger.isLoggable(Level.FINE)) {
 					Container.logger.logp(Level.FINE, "Container", "load(C=null, boolean=" + allVersions + ")",
 						"Exception ignored", e);
 				}
 			}
 		}
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "load(C=" + id + ", boolean=" + allVersions + ")",
 				"end - return value=" + it);
 		}
 		return it;
 	}
 
 	/**
 	 * @see org.ov4j.IContainer#load(java.lang.Comparable[], boolean)
 	 */
 	public Item<T, C>[] load(final C[] ids, final boolean allVersions) throws IOException {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "load(C[]=" + Arrays.toString(ids) + ", boolean=" + allVersions
 				+ ")", "start");
 		}
 
 		final ArrayList<Item<T, C>> list = new ArrayList<Item<T, C>>();
 		if (ids != null) {
 			for (int startIdx = 0; startIdx < ids.length; startIdx += Container.MAX_LOADTHREAD) {
 				final C[] buf = (C[]) new Comparable[Math.min(Container.MAX_LOADTHREAD, (ids.length - startIdx))];
 				System.arraycopy(ids, startIdx, buf, 0, buf.length);
 				final LoadThread<T, C>[] threads = new LoadThread[buf.length];
 				for (int i = 0; i < buf.length; i++) {
 					threads[i] = new LoadThread<T, C>(list, this, buf[i], allVersions);
 					threads[i].start();
 				}
 				for (int i = 0; i < threads.length; i++) {
 					try {
 						threads[i].join();
 					} catch (final InterruptedException e) {
 						if (Container.logger.isLoggable(Level.FINE)) {
 							Container.logger.logp(Level.FINE, "Container", "load(C[]=" + Arrays.toString(ids)
 								+ ", boolean=" + allVersions + ")", "exception ignored", e);
 						}
 					}
 				}
 			}
 		}
 		final Item<T, C>[] returnItemArray = list.toArray((Item<T, C>[]) Item.EMPTY_ARRAY);
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container",
 				"load(C[]=" + Arrays.toString(ids) + ", boolean=" + allVersions + ")", "end - return value="
 					+ Arrays.toString(returnItemArray));
 		}
 		return returnItemArray;
 	}
 
 	/**
 	 * @see org.ov4j.IContainer#modifiedSince(long, boolean)
 	 */
 	public Item<T, C>[] modifiedSince(final long timestamp, final boolean allVersions) throws IOException {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container",
 				"modifiedSince(long=" + timestamp + ", boolean=" + allVersions + ")", "start");
 		}
 
 		final File[] files = liveItems.listFiles(new TStampFileFilter(timestamp));
 		final ArrayList<Item<T, C>> list = new ArrayList<Item<T, C>>();
 		for (int startIdx = 0; startIdx < files.length; startIdx += Container.MAX_LOADTHREAD) {
 			final C[] buf = (C[]) new Comparable[Math.min(Container.MAX_LOADTHREAD, (files.length - startIdx))];
 			for (int i = 0; i < buf.length; i++) {
 				buf[i] = filenameToId(files[i + startIdx].getName());
 			}
 			final LoadThread<T, C>[] threads = new LoadThread[buf.length];
 			for (int i = 0; i < buf.length; i++) {
 				threads[i] = new LoadThread<T, C>(list, this, buf[i], allVersions);
 				threads[i].start();
 			}
 			for (int i = 0; i < threads.length; i++) {
 				try {
 					threads[i].join();
 				} catch (final InterruptedException e) {
 					if (Container.logger.isLoggable(Level.FINE)) {
 						Container.logger.logp(Level.FINE, "Container", "modifiedSince(long=" + timestamp + ", boolean="
 							+ allVersions + ")", "exception ignored", e);
 					}
 				}
 			}
 		}
 		final Item<T, C>[] returnItemArray = list.toArray((Item<T, C>[]) Item.EMPTY_ARRAY);
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "modifiedSince(long=" + timestamp + ", boolean=" + allVersions + ")",
 				"end - return value=" + Arrays.toString(returnItemArray));
 		}
 		return returnItemArray;
 	}
 
 	/**
 	 * Populate the deleted ID map from files.
 	 * 
 	 * @throws IOException
 	 * 
 	 */
 	protected void populateDeletedMap() throws IOException {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "populateDeletedMap()", "start");
 		}
 
 		final File[] files = liveDeleted.listFiles(new StdFileFilter());
 		if (files != null) {
 			for (int i = 0; i < files.length; i++) {
 				final BufferedInputStream fIn = new BufferedInputStream(new FileInputStream(files[i]));
 				final HessianInput in = new HessianInput(fIn);
 				final C id = (C) in.readObject();
 				deletedMap.put(id, files[i].getName());
 				fIn.close();
 			}
 		}
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "populateDeletedMap()", "end");
 		}
 	}
 
 	/**
 	 * Populate the ID map from files.
 	 * 
 	 * @throws IOException
 	 * 
 	 */
 	protected void populateIdMap() throws IOException {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "populateIdMap()", "start");
 		}
 
 		final File[] files = liveItems.listFiles(new StdFileFilter());
 		if (files != null) {
 			for (int i = 0; i < files.length; i++) {
 				final long num = Long.parseLong(files[i].getName());
 				if (num > counter) {
 					counter = num + 1;
 				}
 				final BufferedInputStream fIn = new BufferedInputStream(new FileInputStream(files[i]));
 				final HessianInput in = new HessianInput(fIn);
 				final Item<T, C> it = (Item<T, C>) in.readObject();
 				idMap.put(it.getId(), files[i].getName());
 				revIdMap.put(files[i].getName(), it.getId());
 				fIn.close();
 			}
 		}
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "populateIdMap()", "end");
 		}
 	}
 
 	/**
 	 * @see org.ov4j.IContainer#release(java.lang.Object)
 	 */
 	public void release(final Object obj) {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "release(Object=" + obj + ")", "start");
 		}
 
 		if (obj instanceof Item) {
 			uncacheItem(((Item<T, C>) obj).getId());
 		}
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "release(Object=" + obj + ")", "end");
 		}
 	}
 
 	/**
 	 * @see org.ov4j.IContainer#rollback()
 	 */
 	public void rollback() {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "rollback()", "start");
 		}
 
 		waitForPendingTasks();
 		synchronized (saveLock) {
 			recentMap.clear();
 			cachedIds.clear();
 			idMapWrk.clear();
 			deletedMapWrk.clear();
 			File[] files = workItems.listFiles(Container.FOLDER_FILTER);
 			for (int i = 0; i < files.length; i++) {
 				final File[] subFiles = files[i].listFiles();
 				for (int j = 0; j < subFiles.length; j++) {
 					subFiles[j].delete();
 				}
 			}
 			files = workItems.listFiles();
 			for (int i = 0; i < files.length; i++) {
 				files[i].delete();
 			}
 			files = workDeleted.listFiles();
 			for (int i = 0; i < files.length; i++) {
 				files[i].delete();
 			}
 		}
 		Config.checkMemory();
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "rollback()", "end");
 		}
 	}
 
 	/**
 	 * @see org.ov4j.IContainer#save(org.ov4j.data.Item)
 	 */
 	public void save(final Item<T, C> it) throws IOException {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "save(Item<T,C>=" + it + ")", "start");
 		}
 
 		uncacheItem(it.getId());
 		final Runnable t = new Runnable() {
 			public void run() {
 				synchronized (saveLock) {
 					try {
 						if (it != null && it.getId() != null) {
 							int retry = 0;
 							String filename = idToFilename(it.getId());
 							Version<T>[] vers = it.getVersions();
 							if (vers != null && vers.length > 0) {
 								File folder = new File(workItems, filename + Container.VERSION_FOLDER);
 								folder.mkdir();
 								for (int i = 0; i < vers.length; i++) {
 									while (retry < Container.MAX_RETRY) {
 										try {
 											BufferedOutputStream fOut =
 												new BufferedOutputStream(new FileOutputStream(new File(folder, String
 													.valueOf(vers[i].getVersionNumber()))));
 											HessianOutput out = new HessianOutput(fOut);
 											out.writeObject(vers[i]);
 											fOut.close();
 											break;
 										} catch (Exception e) {
 											if (Container.logger.isLoggable(Level.FINE)) {
 												Container.logger.logp(Level.FINE, "Container", "save(Item<T,C>=" + it
 													+ ")$Runnable.run()", "Exception caught", e);
 											}
 
 											retry++;
 										}
 									}
 								}
 								it.versions(null);
 							}
 							retry = 0;
 							while (retry < Container.MAX_RETRY) {
 								try {
 									BufferedOutputStream fOut =
 										new BufferedOutputStream(new FileOutputStream(new File(workItems, filename)));
 									HessianOutput out = new HessianOutput(fOut);
 									out.writeObject(it);
 									fOut.close();
 									break;
 								} catch (ConcurrentModificationException e) {
 									if (Container.logger.isLoggable(Level.FINE)) {
 										Container.logger.logp(Level.FINE, "Container", "save(Item<T,C>=" + it
 											+ ")$Runnable.run()", "Exception caught", e);
 									}
 
 									retry++;
 								}
 							}
 							idMapWrk.put(it.getId(), filename);
 							revIdMapWrk.put(filename, it.getId());
 						}
 					} catch (IOException e) {
 						if (Container.logger.isLoggable(Level.FINE)) {
 							Container.logger.logp(Level.FINE, "Container", "save(Item<T,C>=" + it + ")$Runnable.run()",
 								"exception ignored", e);
 						}
 					}
 				}
 				synchronized (pendingTasks) {
 					pendingSaves--;
 				}
 			}
 		};
 		synchronized (pendingTasks) {
 			pendingSaves++;
 			pendingTasks.add(t);
 		}
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "save(Item<T,C>=" + it + ")", "end");
 		}
 	}
 
 	/**
 	 * Returns a string representation of this Container.
 	 * 
 	 * @return String representation of the Container.
 	 */
 	public String toString() {
 		return "Container{" + dbName + "}";
 	}
 
 	/**
 	 * Remove an item from cache.
 	 * 
 	 * @param id
 	 *            ID of the item.
 	 */
 	protected void uncacheItem(final C id) {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "uncacheItem(C=" + id + ")", "start");
 		}
 
 		synchronized (recentMap) {
 			if (recentMap.containsKey(id)) {
 				recentMap.remove(id);
 				cachedIds.remove(id);
 			}
 		}
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "uncacheItem(C=" + id + ")", "end");
 		}
 	}
 
 	/**
 	 * @see org.ov4j.IContainer#waitForPendingSaves()
 	 */
 	public void waitForPendingSaves() {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "waitForPendingSaves()", "start");
 		}
 
 		if (!taskExecutorStarted) {
 			synchronized (taskExecutor) {
 				taskExecutorStarted = true;
 				taskExecutor.start();
 			}
 		}
 
 		while (pendingSaves > 0) {
 			try {
 				Thread.sleep(100);
 			} catch (final InterruptedException e) {
 				if (Container.logger.isLoggable(Level.FINE)) {
 					Container.logger.logp(Level.FINE, "Container", "waitForPendingSaves()", "exception ignored", e);
 				}
 			}
 		}
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "waitForPendingSaves()", "end");
 		}
 	}
 
 	/**
 	 * @see org.ov4j.IContainer#waitForPendingTasks()
 	 */
 	public void waitForPendingTasks() {
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.entering("Container", "waitForPendingTasks()", "start");
 		}
 
 		if (!taskExecutorStarted) {
 			initTaskExecutor();
 			synchronized (taskExecutor) {
 				taskExecutorStarted = true;
 				taskExecutor.start();
 			}
 		}
 
 		while (pendingTasks.size() > 0 || runningPendingTasks) {
 			try {
 				Thread.sleep(100);
 			} catch (final InterruptedException e) {
 				if (Container.logger.isLoggable(Level.FINE)) {
 					Container.logger.logp(Level.FINE, "Container", "waitForPendingTasks()", "exception ignored", e);
 				}
 			}
 		}
 
 		if (Container.logger.isLoggable(Level.FINER)) {
 			Container.logger.exiting("Container", "waitForPendingTasks()", "end");
 		}
 	}
 }