public KahaStore(String name,
    String mode) throws IOException 
{
    	this(new File(IOHelper.toFileSystemDirectorySafeName(name)), mode, new AtomicLong());
}

 public KahaStore(File directory,
    String mode) throws IOException 
{
    	this(directory, mode, new AtomicLong());
}

 public KahaStore(String name,
    String mode,
    AtomicLong storeSize) throws IOException 
{
    	this(new File(IOHelper.toFileSystemDirectorySafeName(name)), mode, storeSize);
}

 public KahaStore(File directory,
    String mode,
    AtomicLong storeSize) throws IOException 
{
        this.mode = mode;
        this.storeSize = storeSize;
        this.directory = directory;
        IOHelper.mkdirs(this.directory);
}

 public synchronized  void clear() throws IOException 
{
        initialize();
        for (Iterator i = mapsContainer.getKeys().iterator(); i.hasNext();) {
            ContainerId id = (ContainerId)i.next();
            MapContainer container = getMapContainer(id.getKey(), id.getDataContainerName());
            container.clear();
        }
        for (Iterator i = listsContainer.getKeys().iterator(); i.hasNext();) {
            ContainerId id = (ContainerId)i.next();
            ListContainer container = getListContainer(id.getKey(), id.getDataContainerName());
            container.clear();
        }
}

 public synchronized  void close() throws IOException 
{
        if (!closed) {
            closed = true;
            if (initialized) {
                unlock();
                for (ListContainerImpl container : lists.values()) {
                    container.close();
                }
                lists.clear();
                for (MapContainerImpl container : maps.values()) {
                    container.close();
                }
                maps.clear();
                for (Iterator< IndexManager > iter = indexManagers.values().iterator(); iter.hasNext();) {
                    IndexManager im = iter.next();
                    im.close();
                    iter.remove();
                }
                for (Iterator< DataManager > iter = dataManagers.values().iterator(); iter.hasNext();) {
                    DataManager dm = iter.next();
                    dm.close();
                    iter.remove();
                }
            }
            if (lockFile!=null) {
                lockFile.close();
                lockFile=null;
            }
        }
}

 public synchronized boolean delete() throws IOException 
{
        boolean result = true;
        if (initialized) {
            clear();
            for (Iterator< IndexManager > iter = indexManagers.values().iterator(); iter.hasNext();) {
                IndexManager im = iter.next();
                result &= im.delete();
                iter.remove();
            }
            for (Iterator< DataManager > iter = dataManagers.values().iterator(); iter.hasNext();) {
                DataManager dm = iter.next();
                result &= dm.delete();
                iter.remove();
            }
        }
        if (directory != null && directory.isDirectory()) {
            result =IOHelper.deleteChildren(directory);
            String str = result ? "successfully deleted" : "failed to delete";
            LOG.info("Kaha Store " + str + " data directory " + directory);
        }
        return result;
}

 public  void deleteListContainer(Object id) throws IOException 
{
        deleteListContainer(id, defaultContainerName);
}

 public synchronized  void deleteListContainer(ContainerId containerId) throws IOException 
{
        initialize();
        ListContainerImpl container = lists.remove(containerId);
        if (container != null) {
            listsContainer.removeRoot(container.getIndexManager(), containerId);
            container.clear();
            container.close();
        }
}

 public synchronized  void deleteListContainer(Object id,
    String containerName) throws IOException 
{
        ContainerId containerId = new ContainerId(id, containerName);
        deleteListContainer(containerId);
}

 public  void deleteMapContainer(Object id) throws IOException 
{
        deleteMapContainer(id, defaultContainerName);
}

 public synchronized  void deleteMapContainer(ContainerId containerId) throws IOException 
{
        initialize();
        MapContainerImpl container = maps.remove(containerId);
        if (container != null) {
            container.clear();
            mapsContainer.removeRoot(container.getIndexManager(), containerId);
            container.close();
        }
}

 public  void deleteMapContainer(Object id,
    String containerName) throws IOException 
{
        ContainerId containerId = new ContainerId(id, containerName);
        deleteMapContainer(containerId);
}

 public boolean doesListContainerExist(Object id) throws IOException 
{
        return doesListContainerExist(id, defaultContainerName);
}

 public synchronized boolean doesListContainerExist(Object id,
    String containerName) throws IOException 
{
        initialize();
        ContainerId containerId = new ContainerId(id, containerName);
        return lists.containsKey(containerId) || listsContainer.doesRootExist(containerId);
}

 public boolean doesMapContainerExist(Object id) throws IOException 
{
        return doesMapContainerExist(id, defaultContainerName);
}

 public synchronized boolean doesMapContainerExist(Object id,
    String containerName) throws IOException 
{
        initialize();
        ContainerId containerId = new ContainerId(id, containerName);
        return maps.containsKey(containerId) || mapsContainer.doesRootExist(containerId);
}

 public synchronized  void force() throws IOException 
{
        if (initialized) {
            for (Iterator< IndexManager > iter = indexManagers.values().iterator(); iter.hasNext();) {
                IndexManager im = iter.next();
                im.force();
            }
            for (Iterator< DataManager > iter = dataManagers.values().iterator(); iter.hasNext();) {
                DataManager dm = iter.next();
                dm.force();
            }
        }
}

 public synchronized DataManager getDataManager(String name) throws IOException 
{
        DataManager dm = dataManagers.get(name);
        if (dm == null) {
            if (isUseAsyncDataManager()) {
                AsyncDataManager t = new AsyncDataManager(storeSize);
                t.setDirectory(directory);
                t.setFilePrefix("async-data-" + name + "-");
                t.setMaxFileLength((int)maxDataFileLength);
                t.start();
                dm = new DataManagerFacade(t, name);
            } else {
                DataManagerImpl t = new DataManagerImpl(directory, name,storeSize);
                t.setMaxFileLength(maxDataFileLength);
                dm = t;
            }
            if (logIndexChanges) {
                recover(dm);
            }
            dataManagers.put(name, dm);
        }
        return dm;
}

 public String getDefaultContainerName() 
{
        return defaultContainerName;
}

 public synchronized IndexManager getIndexManager(DataManager dm,
    String name) throws IOException 
{
        IndexManager im = indexManagers.get(name);
        if (im == null) {
            im = new IndexManager(directory, name, mode, logIndexChanges ? dm : null,storeSize);
            indexManagers.put(name, im);
        }
        return im;
}

 public synchronized String getIndexTypeAsString() 
{
        return persistentIndex ? "PERSISTENT" : "VM";
}

 public ListContainer getListContainer(Object id) throws IOException 
{
        return getListContainer(id, defaultContainerName);
}

 public ListContainer getListContainer(Object id,
    String containerName) throws IOException 
{
        return getListContainer(id, containerName, persistentIndex);
}

 public synchronized ListContainer getListContainer(Object id,
    String containerName,
    boolean persistentIndex) throws IOException 
{
        initialize();
        ContainerId containerId = new ContainerId(id, containerName);
        ListContainerImpl result = lists.get(containerId);
        if (result == null) {
            DataManager dm = getDataManager(containerName);
            IndexManager im = getIndexManager(dm, containerName);
            IndexItem root = listsContainer.getRoot(im, containerId);
            if (root == null) {
                root = listsContainer.addRoot(im, containerId);
            }
            result = new ListContainerImpl(containerId, root, im, dm, persistentIndex);
            lists.put(containerId, result);
        }
        return result;
}

 public synchronized Set<ContainerId> getListContainerIds() throws IOException 
{
        initialize();
        Set< ContainerId > set = new HashSet< ContainerId >();
        for (Iterator i = listsContainer.getKeys().iterator(); i.hasNext();) {
            ContainerId id = (ContainerId)i.next();
            set.add(id);
        }
        return set;
}

 public IndexRootContainer getListsContainer() 
{
        return this.listsContainer;
}

 public MapContainer getMapContainer(Object id) throws IOException 
{
        return getMapContainer(id, defaultContainerName);
}

 public MapContainer getMapContainer(Object id,
    String containerName) throws IOException 
{
        return getMapContainer(id, containerName, persistentIndex);
}

 public synchronized MapContainer getMapContainer(Object id,
    String containerName,
    boolean persistentIndex) throws IOException 
{
        initialize();
        ContainerId containerId = new ContainerId(id, containerName);
        MapContainerImpl result = maps.get(containerId);
        if (result == null) {
            DataManager dm = getDataManager(containerName);
            IndexManager im = getIndexManager(dm, containerName);
            IndexItem root = mapsContainer.getRoot(im, containerId);
            if (root == null) {
                root = mapsContainer.addRoot(im, containerId);
            }
            result = new MapContainerImpl(directory, containerId, root, im, dm, persistentIndex);
            maps.put(containerId, result);
        }
        return result;
}

 public synchronized Set<ContainerId> getMapContainerIds() throws IOException 
{
        initialize();
        Set< ContainerId > set = new HashSet< ContainerId >();
        for (Iterator i = mapsContainer.getKeys().iterator(); i.hasNext();) {
            ContainerId id = (ContainerId)i.next();
            set.add(id);
        }
        return set;
}

 public IndexRootContainer getMapsContainer() 
{
        return this.mapsContainer;
}

 public synchronized long getMaxDataFileLength() 
{
        return maxDataFileLength;
}

 public synchronized  void initialize() throws IOException 
{
        if (closed) {
            throw new IOException("Store has been closed.");
        }
        if (!initialized) {       
            LOG.info("Kaha Store using data directory " + directory);
            lockFile = new RandomAccessFile(new File(directory, "lock"), "rw");
            lock();
            DataManager defaultDM = getDataManager(defaultContainerName);
            IndexManager rootIndexManager = getIndexManager(defaultDM, defaultContainerName);
            IndexItem mapRoot = new IndexItem();
            IndexItem listRoot = new IndexItem();
            if (rootIndexManager.isEmpty()) {
                mapRoot.setOffset(0);
                rootIndexManager.storeIndex(mapRoot);
                listRoot.setOffset(IndexItem.INDEX_SIZE);
                rootIndexManager.storeIndex(listRoot);
                rootIndexManager.setLength(IndexItem.INDEX_SIZE * 2);
            } else {
                mapRoot = rootIndexManager.getIndex(0);
                listRoot = rootIndexManager.getIndex(IndexItem.INDEX_SIZE);
            }
            initialized = true;
            mapsContainer = new IndexRootContainer(mapRoot, rootIndexManager, defaultDM);
            listsContainer = new IndexRootContainer(listRoot, rootIndexManager, defaultDM);
            /**
             * Add interest in data files - then consolidate them
             */
            generateInterestInMapDataFiles();
            generateInterestInListDataFiles();
            for (Iterator< DataManager > i = dataManagers.values().iterator(); i.hasNext();) {
                DataManager dm = i.next();
                dm.consolidateDataFiles();
            }
        }
}

 public synchronized boolean isInitialized() 
{
        return initialized;
}

 public synchronized boolean isLogIndexChanges() 
{
        return logIndexChanges;
}

 public boolean isPersistentIndex() 
{
		return persistentIndex;
}

 public synchronized boolean isUseAsyncDataManager() 
{
        return useAsyncDataManager;
}

 public  void setDefaultContainerName(String defaultContainerName) 
{
        this.defaultContainerName = defaultContainerName;
}

 public synchronized  void setIndexTypeAsString(String type) 
{
        if (type.equalsIgnoreCase("VM")) {
            persistentIndex = false;
        } else {
            persistentIndex = true;
        }
}

Set the default index type

 public synchronized  void setLogIndexChanges(boolean logIndexChanges) 
{
        this.logIndexChanges = logIndexChanges;
}

 public synchronized  void setMaxDataFileLength(long maxDataFileLength) 
{
        this.maxDataFileLength = maxDataFileLength;
}

 public  void setPersistentIndex(boolean persistentIndex) 
{
		this.persistentIndex = persistentIndex;
}

 public synchronized  void setUseAsyncDataManager(boolean useAsyncWriter) 
{
        this.useAsyncDataManager = useAsyncWriter;
}

 public long size() 
{
        return storeSize.get();
}