public synchronized void deleteCollection(String name) {
try {
long nameDirectory_recid = getRoot(NAME_DIRECTORY_ROOT);
if (nameDirectory_recid == 0) throw new IOException("Collection not found");
HTree<String, Long> dir = fetch(nameDirectory_recid);
Long recid = dir.get(name);
if (recid == null) throw new IOException("Collection not found");
Object o = fetch(recid);
// we can not use O instance since it is not correctly initialized
if (o instanceof LinkedList2) {
LinkedList2 l = (LinkedList2) o;
l.clear();
delete(l.rootRecid);
} else if (o instanceof BTree) {
((BTree) o).clear();
} else if (o instanceof HTree) {
HTree t = (HTree) o;
t.clear();
HTreeDirectory n = (HTreeDirectory) fetch(t.rootRecid, t.SERIALIZER);
n.deleteAllChildren();
delete(t.rootRecid);
} else {
throw new InternalError("unknown collection type: " + (o == null ? null : o.getClass()));
}
delete(recid);
collections.remove(name);
dir.remove(name);
} catch (IOException e) {
throw new IOError(e);
}
}
/**
* Obtain the record id of a named object. Returns 0 if named object doesn't exist. Named objects
* are used to store Map views and other well known objects.
*/
protected synchronized long getNamedObject(String name) throws IOException {
long nameDirectory_recid = getRoot(NAME_DIRECTORY_ROOT);
if (nameDirectory_recid == 0) {
return 0;
}
HTree<String, Long> m = fetch(nameDirectory_recid);
Long res = m.get(name);
if (res == null) return 0;
return res;
}
/**
* Set the record id of a named object. Named objects are used to store Map views and other well
* known objects.
*/
protected synchronized void setNamedObject(String name, long recid) throws IOException {
long nameDirectory_recid = getRoot(NAME_DIRECTORY_ROOT);
HTree<String, Long> m = null;
if (nameDirectory_recid == 0) {
// does not exists, create it
m = new HTree<String, Long>(this, null, null, true);
nameDirectory_recid = insert(m);
setRoot(NAME_DIRECTORY_ROOT, nameDirectory_recid);
} else {
// fetch it
m = fetch(nameDirectory_recid);
}
m.put(name, recid);
}
public synchronized <K, V> ConcurrentMap<K, V> getHashMap(String name) {
Object o = getCollectionInstance(name);
if (o != null) return (ConcurrentMap<K, V>) o;
try {
long recid = getNamedObject(name);
if (recid == 0) return null;
HTree tree = fetch(recid);
tree.setPersistenceContext(this);
if (!tree.hasValues()) {
throw new ClassCastException("HashSet is not HashMap");
}
collections.put(name, new WeakReference<Object>(tree));
return tree;
} catch (IOException e) {
throw new IOError(e);
}
}
public synchronized <K> Set<K> getHashSet(String name) {
Object o = getCollectionInstance(name);
if (o != null) return (Set<K>) o;
try {
long recid = getNamedObject(name);
if (recid == 0) return null;
HTree tree = fetch(recid);
tree.setPersistenceContext(this);
if (tree.hasValues()) {
throw new ClassCastException("HashMap is not HashSet");
}
Set<K> ret = new HTreeSet(tree);
collections.put(name, new WeakReference<Object>(ret));
return ret;
} catch (IOException e) {
throw new IOError(e);
}
}
public synchronized Map<String, Object> getCollections() {
try {
Map<String, Object> ret = new LinkedHashMap<String, Object>();
long nameDirectory_recid = getRoot(NAME_DIRECTORY_ROOT);
if (nameDirectory_recid == 0) return ret;
HTree<String, Long> m = fetch(nameDirectory_recid);
for (Map.Entry<String, Long> e : m.entrySet()) {
Object o = fetch(e.getValue());
if (o instanceof BTree) {
if (((BTree) o).hasValues) o = getTreeMap(e.getKey());
else o = getTreeSet(e.getKey());
} else if (o instanceof HTree) {
if (((HTree) o).hasValues) o = getHashMap(e.getKey());
else o = getHashSet(e.getKey());
}
ret.put(e.getKey(), o);
}
return Collections.unmodifiableMap(ret);
} catch (IOException e) {
throw new IOError(e);
}
}