public void testP2OMap() {
// Long-long
TLongObjectHashMap<Long> lomap = new TLongObjectHashMap<Long>();
assertTrue(serializesCorrectly(lomap, "p2o-l-1"));
lomap.put(0, Long.valueOf(1));
assertTrue(serializesCorrectly(lomap, "p2o-l-2"));
lomap.put(Long.MIN_VALUE, Long.valueOf(Long.MIN_VALUE));
assertTrue(serializesCorrectly(lomap, "p2o-l-3"));
lomap.put(Long.MAX_VALUE, Long.valueOf(Long.MAX_VALUE));
assertTrue(serializesCorrectly(lomap, "p2o-l-4"));
// Int-int
TIntObjectHashMap<Integer> iomap = new TIntObjectHashMap<Integer>();
assertTrue(serializesCorrectly(iomap, "p2o-i-1"));
iomap.put(0, Integer.valueOf(1));
assertTrue(serializesCorrectly(iomap, "p2o-i-2"));
iomap.put(Integer.MIN_VALUE, Integer.valueOf(Integer.MIN_VALUE));
assertTrue(serializesCorrectly(iomap, "p2o-i-3"));
iomap.put(Integer.MAX_VALUE, Integer.valueOf(Integer.MAX_VALUE));
assertTrue(serializesCorrectly(iomap, "p2o-i-4"));
// Double-double
TDoubleObjectHashMap<Double> domap = new TDoubleObjectHashMap<Double>();
assertTrue(serializesCorrectly(domap, "p2o-d-1"));
domap.put(0, Double.valueOf(1));
assertTrue(serializesCorrectly(domap, "p2o-d-2"));
domap.put(Double.MIN_VALUE, Double.valueOf(Double.MIN_VALUE));
assertTrue(serializesCorrectly(domap, "p2o-d-3"));
domap.put(Double.MAX_VALUE, Double.valueOf(Double.MAX_VALUE));
assertTrue(serializesCorrectly(domap, "p2o-d-4"));
domap.put(Double.POSITIVE_INFINITY, Double.valueOf(Double.POSITIVE_INFINITY));
assertTrue(serializesCorrectly(domap, "p2o-d-5"));
domap.put(Double.NEGATIVE_INFINITY, Double.valueOf(Double.NEGATIVE_INFINITY));
assertTrue(serializesCorrectly(domap, "p2o-d-6"));
// NOTE: trove doesn't deal well with NaN
// ddmap.put( Double.NaN, Double.NaN );
// assertTrue( serializesCorrectly( ddmap ) );
// Float-float
TFloatObjectHashMap<Float> fomap = new TFloatObjectHashMap<Float>();
assertTrue(serializesCorrectly(fomap, "p2o-f-1"));
fomap.put(0, Float.valueOf(1));
assertTrue(serializesCorrectly(fomap, "p2o-f-2"));
fomap.put(Float.MIN_VALUE, Float.valueOf(Float.MIN_VALUE));
assertTrue(serializesCorrectly(fomap, "p2o-f-3"));
fomap.put(Float.MAX_VALUE, Float.valueOf(Float.MAX_VALUE));
assertTrue(serializesCorrectly(fomap, "p2o-f-4"));
fomap.put(Float.POSITIVE_INFINITY, Float.valueOf(Float.POSITIVE_INFINITY));
assertTrue(serializesCorrectly(fomap, "p2o-f-5"));
fomap.put(Float.NEGATIVE_INFINITY, Float.valueOf(Float.NEGATIVE_INFINITY));
assertTrue(serializesCorrectly(fomap, "p2o-f-6"));
// NOTE: trove doesn't deal well with NaN
// ffmap.put( Float.NaN, Float.NaN );
// assertTrue( serializesCorrectly( ffmap ) );
}
public void forall(Category c) {
FeatureStructure fs = c.getFeatureStructure();
if (fs != null && fs.getIndex() != 0) featStrucMap.put(fs.getIndex(), fs);
}
@Override
@Nullable
public VirtualFileSystemEntry findRoot(
@NotNull String basePath, @NotNull NewVirtualFileSystem fs) {
if (basePath.isEmpty()) {
LOG.error("Invalid root, fs=" + fs);
return null;
}
String rootUrl = normalizeRootUrl(basePath, fs);
myRootsLock.readLock().lock();
try {
VirtualFileSystemEntry root = myRoots.get(rootUrl);
if (root != null) return root;
} finally {
myRootsLock.readLock().unlock();
}
final VirtualFileSystemEntry newRoot;
int rootId = FSRecords.findRootRecord(rootUrl);
VfsData.Segment segment = VfsData.getSegment(rootId, true);
VfsData.DirectoryData directoryData = new VfsData.DirectoryData();
if (fs instanceof ArchiveFileSystem) {
String parentPath =
basePath.substring(0, basePath.indexOf(ArchiveFileSystem.ARCHIVE_SEPARATOR));
VirtualFile parentFile = LocalFileSystem.getInstance().findFileByPath(parentPath);
if (parentFile == null) return null;
FileType type = FileTypeRegistry.getInstance().getFileTypeByFileName(parentFile.getName());
if (!(type instanceof ArchiveFileType)) return null;
newRoot = new ArchiveRoot(fs, rootId, segment, directoryData, parentFile);
} else {
newRoot = new FsRoot(fs, rootId, segment, directoryData, basePath);
}
FileAttributes attributes =
fs.getAttributes(
new StubVirtualFile() {
@NotNull
@Override
public String getPath() {
return newRoot.getPath();
}
@Nullable
@Override
public VirtualFile getParent() {
return null;
}
});
if (attributes == null || !attributes.isDirectory()) {
return null;
}
boolean mark = false;
myRootsLock.writeLock().lock();
try {
VirtualFileSystemEntry root = myRoots.get(rootUrl);
if (root != null) return root;
VfsData.initFile(rootId, segment, -1, directoryData);
mark = writeAttributesToRecord(rootId, 0, newRoot, fs, attributes);
myRoots.put(rootUrl, newRoot);
myRootsById.put(rootId, newRoot);
} finally {
myRootsLock.writeLock().unlock();
}
if (!mark && attributes.lastModified != FSRecords.getTimestamp(rootId)) {
newRoot.markDirtyRecursively();
}
LOG.assertTrue(
rootId == newRoot.getId(),
"root=" + newRoot + " expected=" + rootId + " actual=" + newRoot.getId());
return newRoot;
}
@Override
@Nullable
public VirtualFileSystemEntry findRoot(
@NotNull String basePath, @NotNull NewVirtualFileSystem fs) {
String rootUrl = normalizeRootUrl(basePath, fs);
boolean isFakeRoot = basePath.isEmpty();
VirtualFileSystemEntry root;
myRootsLock.readLock().lock();
try {
root = isFakeRoot ? mySuperRoot : myRoots.get(rootUrl);
if (root != null) return root;
} finally {
myRootsLock.readLock().unlock();
}
myRootsLock.writeLock().lock();
try {
root = isFakeRoot ? mySuperRoot : myRoots.get(rootUrl);
if (root != null) return root;
int rootId = FSRecords.findRootRecord(rootUrl);
root = myRootsById.get(rootId);
if (root != null) return root;
if (isFakeRoot) {
// fake super-root
root = new FakeRoot(fs, rootId);
} else if (fs instanceof JarFileSystem) {
// optimization: for jar roots do not store base path in the myName field, use local FS
// file's getPath()
String parentPath = basePath.substring(0, basePath.indexOf(JarFileSystem.JAR_SEPARATOR));
VirtualFile parentLocalFile = LocalFileSystem.getInstance().findFileByPath(parentPath);
if (parentLocalFile == null) return null;
// check one more time since the findFileByPath could have created the root (by reentering
// the findRoot)
root = myRoots.get(rootUrl);
if (root != null) return root;
root = myRootsById.get(rootId);
if (root != null) return root;
root = new JarRoot(fs, rootId, parentLocalFile);
} else {
root = new FsRoot(fs, rootId, basePath);
}
if (isFakeRoot) {
mySuperRoot = root;
} else {
FileAttributes attributes = fs.getAttributes(root);
if (attributes == null || !attributes.isDirectory()) {
return null;
}
final boolean newRoot = writeAttributesToRecord(rootId, 0, root, fs, attributes);
if (!newRoot && attributes.lastModified != FSRecords.getTimestamp(rootId)) {
root.markDirtyRecursively();
}
myRoots.put(rootUrl, root);
myRootsById.put(rootId, root);
if (rootId != root.getId()) throw new AssertionError();
}
return root;
} finally {
myRootsLock.writeLock().unlock();
}
}