/** {@inheritDoc} */
public void putAll(Map<? extends Integer, ? extends Integer> map) {
ensureCapacity(map.size());
// could optimize this for cases when map instanceof THashMap
for (Map.Entry<? extends Integer, ? extends Integer> entry : map.entrySet()) {
this.put(entry.getKey().intValue(), entry.getValue().intValue());
}
}
// returns a macro adder for the given morph item
private MacroAdder getMacAdder(MorphItem mi) {
// check map
MacroAdder retval = macAdderMap.get(mi);
if (retval != null) return retval;
// set up macro adder
IntHashSetMap macrosFromLex = new IntHashSetMap();
String[] newMacroNames = mi.getMacros();
List<MacroItem> macroItems = new ArrayList<MacroItem>();
for (int i = 0; i < newMacroNames.length; i++) {
Set<FeatureStructure> featStrucs = (Set<FeatureStructure>) _macros.get(newMacroNames[i]);
if (featStrucs != null) {
for (Iterator<FeatureStructure> fsIt = featStrucs.iterator(); fsIt.hasNext(); ) {
FeatureStructure fs = fsIt.next();
macrosFromLex.put(fs.getIndex(), fs);
}
}
MacroItem macroItem = _macroItems.get(newMacroNames[i]);
if (macroItem != null) {
macroItems.add(macroItem);
} else {
// should be checked earlier too
System.err.println(
"Warning: macro " + newMacroNames[i] + " not found for word '" + mi.getWord() + "'");
}
}
retval = new MacroAdder(macrosFromLex, macroItems);
// update map and return
macAdderMap.put(mi, retval);
return retval;
}
private void executeDelete(@NotNull VirtualFile file) {
if (!file.exists()) {
LOG.error("Deleting a file, which does not exist: " + file.getPath());
return;
}
clearIdCache();
int id = getFileId(file);
final VirtualFile parent = file.getParent();
final int parentId = parent == null ? 0 : getFileId(parent);
if (parentId == 0) {
String rootUrl =
normalizeRootUrl(file.getPath(), (NewVirtualFileSystem) file.getFileSystem());
myRootsLock.writeLock().lock();
try {
myRoots.remove(rootUrl);
myRootsById.remove(id);
FSRecords.deleteRootRecord(id);
} finally {
myRootsLock.writeLock().unlock();
}
} else {
removeIdFromParentList(parentId, id, parent, file);
VirtualDirectoryImpl directory = (VirtualDirectoryImpl) file.getParent();
assert directory != null : file;
directory.removeChild(file);
}
FSRecords.deleteRecordRecursively(id);
invalidateSubtree(file);
}
void setVariableState(DfaVariableValue dfaVar, DfaVariableState state) {
assert !myUnknownVariables.contains(dfaVar);
if (state.equals(myDefaultVariableStates.get(dfaVar))) {
myVariableStates.remove(dfaVar);
} else {
myVariableStates.put(dfaVar, state);
}
myCachedHash = null;
}
@Override
@NotNull
public VirtualFile[] getRoots() {
myRootsLock.readLock().lock();
try {
Collection<VirtualFileSystemEntry> roots = myRoots.values();
return VfsUtilCore.toVirtualFileArray(roots);
} finally {
myRootsLock.readLock().unlock();
}
}
public void modify(Mutable m) {
if (m instanceof NominalVar) {
NominalVar nv = (NominalVar) m;
SimpleType st = nv.getType();
SimpleType st0 = nomvarMap.get(nv);
// add type to map if no type found
if (st0 == null) {
nomvarMap.put(nv, st);
return;
}
// check equality
if (st.equals(st0)) return;
// otherwise unify types, update nv and map
try {
SimpleType stU = (SimpleType) st.unify(st0, null);
nv.setType(stU);
nomvarMap.put(nv, stU);
} catch (UnifyFailure uf) {
throw new TypePropagationException(st, st0);
}
}
}
DfaVariableState getVariableState(DfaVariableValue dfaVar) {
DfaVariableState state = myVariableStates.get(dfaVar);
if (state == null) {
state = myDefaultVariableStates.get(dfaVar);
if (state == null) {
state = createVariableState(dfaVar);
DfaTypeValue initialType = dfaVar.getTypeValue();
if (initialType != null) {
state = state.withInstanceofValue(initialType);
assert state != null;
}
myDefaultVariableStates.put(dfaVar, state);
}
if (isUnknownState(dfaVar)) {
return state.withNullable(false);
}
}
return state;
}
@Override
@NotNull
public VirtualFile[] getLocalRoots() {
List<VirtualFile> roots = ContainerUtil.newSmartList();
myRootsLock.readLock().lock();
try {
for (NewVirtualFile root : myRoots.values()) {
if (root.isInLocalFileSystem() && !(root.getFileSystem() instanceof TempFileSystem)) {
roots.add(root);
}
}
} finally {
myRootsLock.readLock().unlock();
}
return VfsUtilCore.toVirtualFileArray(roots);
}
@Override
@NotNull
public VirtualFile[] getRoots(@NotNull final NewVirtualFileSystem fs) {
final List<VirtualFile> roots = new ArrayList<VirtualFile>();
myRootsLock.readLock().lock();
try {
for (NewVirtualFile root : myRoots.values()) {
if (root.getFileSystem() == fs) {
roots.add(root);
}
}
} finally {
myRootsLock.readLock().unlock();
}
return VfsUtilCore.toVirtualFileArray(roots);
}
@Override
public int getId(
@NotNull final VirtualFile parent,
@NotNull final String childName,
@NotNull final NewVirtualFileSystem fs) {
if (parent == mySuperRoot) {
String rootUrl = normalizeRootUrl(childName, fs);
VirtualFileSystemEntry root = myRoots.get(rootUrl);
return root == null ? 0 : root.getId();
}
int parentId = getFileId(parent);
int[] children = FSRecords.list(parentId);
if (children.length > 0) {
// fast path, check that some child has same nameId as given name, this avoid O(N) on
// retrieving names for processing non-cached children
int nameId = FSRecords.getNameId(childName);
for (final int childId : children) {
if (nameId == FSRecords.getNameId(childId)) {
return childId;
}
}
// for case sensitive system the above check is exhaustive in consistent state of vfs
}
for (final int childId : children) {
if (namesEqual(fs, childName, FSRecords.getName(childId))) return childId;
}
final VirtualFile fake = new FakeVirtualFile(parent, childName);
final FileAttributes attributes = fs.getAttributes(fake);
if (attributes != null) {
final int child = createAndFillRecord(fs, fake, parentId, attributes);
FSRecords.updateList(parentId, ArrayUtil.append(children, child));
return child;
}
return 0;
}
@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;
}
// given EntriesItem
private void getWithEntriesItem(
Word w,
MorphItem mi,
String stem,
String pred,
String targetPred,
String targetRel,
EntriesItem item,
MacroAdder macAdder,
Map<String, Double> supertags,
Set<String> supertagsFound,
SignHash result) {
// ensure apropos
if (targetPred != null && !targetPred.equals(pred)) return;
if (targetRel != null
&& !targetRel.equals(item.getIndexRel())
&& !targetRel.equals(item.getCoartRel())) return;
if (!item.getActive().booleanValue()) return;
if (mi.excluded(item)) return;
try {
// copy and add macros
Category cat = item.getCat().copy();
macAdder.addMacros(cat);
// replace DEFAULT_VAL with pred, after first
// unifying type of associated nom var(s) with sem class
unifySemClass(cat, mi.getWord().getSemClass());
REPLACEMENT = pred;
cat.deepMap(defaultReplacer);
// check supertag
// TODO: think about earlier checks for efficiency, for grammars where macros and preds don't
// matter
// Double lexprob = null; // nb: skipping lex log probs, don't seem to be helpful
if (supertags != null) {
// skip if not found
String stag = cat.getSupertag();
if (!supertags.containsKey(stag)) return;
// otherwise update found supertags
supertagsFound.add(stag);
// get lex prob
// lexprob = supertags.get(stag);
}
// propagate types of nom vars
propagateTypes(cat);
// handle distrib attrs and inherits-from
propagateDistributiveAttrs(cat);
expandInheritsFrom(cat);
// merge stem, pos, sem class from morph item, plus supertag from cat
Word word = Word.createFullWord(w, mi.getWord(), cat.getSupertag());
// set origin and lexprob
Sign sign = new Sign(word, cat);
sign.setOrigin();
// if (lexprob != null) {
// sign.addData(new SupertaggerAdapter.LexLogProb((float) Math.log10(lexprob)));
// }
// return sign
result.insert(sign);
} catch (RuntimeException exc) {
System.err.println(
"Warning: ignoring entry: "
+ item.getName()
+ " of family: "
+ item.getFamilyName()
+ " for stem: "
+ stem
+ " b/c: "
+ exc.toString());
}
}
// given MorphItem
private void getWithMorphItem(
Word w, MorphItem mi, String targetPred, String targetRel, SignHash result)
throws LexException {
// get supertags for filtering, if a supertagger is installed
Map<String, Double> supertags = null;
Set<String> supertagsFound = null;
if (_supertagger != null) {
supertags = _supertagger.getSupertags();
if (supertags != null) supertagsFound = new HashSet<String>(supertags.size());
}
// get macro adder
MacroAdder macAdder = getMacAdder(mi);
// if we have this stem in our lexicon
String stem = mi.getWord().getStem();
String pos = mi.getWord().getPOS();
Set<EntriesItem[]> explicitEntries =
null; // for storing entries from explicitly listed family members
if (_stems.containsKey(stem + pos)) {
explicitEntries = new HashSet<EntriesItem[]>();
Collection<Object> stemItems = (Collection<Object>) _stems.get(stem + pos);
for (Iterator<Object> I = stemItems.iterator(); I.hasNext(); ) {
Object item = I.next();
// see if it's an EntriesItem
if (item instanceof EntriesItem) {
EntriesItem entry = (EntriesItem) item;
// do lookup
getWithEntriesItem(
w,
mi,
stem,
stem,
targetPred,
targetRel,
entry,
macAdder,
supertags,
supertagsFound,
result);
}
// otherwise it has to be a Pair containing a DataItem and
// an EntriesItem[]
else {
@SuppressWarnings("rawtypes")
DataItem dItem = (DataItem) ((Pair) item).a;
@SuppressWarnings("rawtypes")
EntriesItem[] entries = (EntriesItem[]) ((Pair) item).b;
// store entries
explicitEntries.add(entries);
// do lookup
getWithDataItem(
w,
mi,
dItem,
entries,
targetPred,
targetRel,
macAdder,
supertags,
supertagsFound,
result);
}
}
}
// for entries that are not explicitly in the lexicon file, we have to create
// Signs from the open class entries with the appropriate part-of-speech
Collection<EntriesItem[]> entrySets = (Collection<EntriesItem[]>) _posToEntries.get(pos);
if (entrySets != null) {
for (Iterator<EntriesItem[]> E = entrySets.iterator(); E.hasNext(); ) {
EntriesItem[] entries = E.next();
// skip if entries explicitly listed
if (explicitEntries != null && explicitEntries.contains(entries)) continue;
// otherwise get entries with pred = targetPred, or stem if null
String pred = (targetPred != null) ? targetPred : stem;
getWithDataItem(
w,
mi,
new DataItem(stem, pred),
entries,
targetPred,
targetRel,
macAdder,
supertags,
supertagsFound,
result);
}
}
// finally do entries for any remaining supertags
if (supertags != null) {
for (String supertag : supertags.keySet()) {
if (supertagsFound.contains(supertag)) continue;
Set<EntriesItem> entries = _stagToEntries.get(supertag + pos);
if (entries == null) continue; // nb: could be a POS mismatch
// get entries with pred = targetPred, or stem if null
String pred = (targetPred != null) ? targetPred : stem;
for (EntriesItem entry : entries) {
if (!entry.getStem().equals(DEFAULT_VAL)) continue;
getWithEntriesItem(
w,
mi,
stem,
pred,
targetPred,
targetRel,
entry,
macAdder,
supertags,
supertagsFound,
result);
}
}
}
}
@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();
}
}
