/*
* Copyright (c) 2014, the Dart project authors.
*
* Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except
* in compliance with the License. You may obtain a copy of the License at
*
* http://www.eclipse.org/legal/epl-v10.html
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.dart.engine.internal.index.file;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.google.dart.engine.AnalysisEngine;
import com.google.dart.engine.context.AnalysisContext;
import com.google.dart.engine.element.CompilationUnitElement;
import com.google.dart.engine.element.Element;
import com.google.dart.engine.element.ElementKind;
import com.google.dart.engine.element.HtmlElement;
import com.google.dart.engine.element.LibraryElement;
import com.google.dart.engine.index.IndexStore;
import com.google.dart.engine.index.Location;
import com.google.dart.engine.index.Relationship;
import com.google.dart.engine.index.UniverseElement;
import com.google.dart.engine.internal.context.AnalysisContextImpl;
import com.google.dart.engine.internal.context.InstrumentedAnalysisContextImpl;
import com.google.dart.engine.source.Source;
import com.google.dart.engine.source.SourceContainer;
import org.apache.commons.lang3.ArrayUtils;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
* An {@link IndexStore} which keeps index information in separate nodes for each unit.
*
* @coverage dart.engine.index
*/
public class SplitIndexStoreImpl implements IndexStore {
/**
* The {@link NodeManager} to get/put {@link IndexNode}s.
*/
private final NodeManager nodeManager;
/**
* The {@link ContextCodec} to encode/decode {@link AnalysisContext}s.
*/
private final ContextCodec contextCodec;
/**
* The {@link ElementCodec} to encode/decode {@link Element}s.
*/
private final ElementCodec elementCodec;
/**
* The {@link StringCodec} to encode/decode {@link String}s.
*/
private final StringCodec stringCodec;
/**
* A table mapping elements to the node names that may have relations with these elements.
*/
private final IntToIntSetMap elementToNodeNames = new IntToIntSetMap(10000, 0.75f);
/**
* Information about "universe" elements. We need to keep them together to avoid loading of all
* index nodes.
* <p>
* Order of keys: contextId, nodeId, Relationship.
*/
private final Map<Integer, Map<Integer, Map<Relationship, List<LocationData>>>> contextNodeRelations = Maps.newHashMap();
/**
* The mapping of library {@link Source} to the {@link Source}s of part units.
*/
final Map<AnalysisContext, Map<Source, Set<Source>>> contextToLibraryToUnits = Maps.newHashMap();
/**
* The mapping of unit {@link Source} to the {@link Source}s of libraries it is used in.
*/
final Map<AnalysisContext, Map<Source, Set<Source>>> contextToUnitToLibraries = Maps.newHashMap();
/**
* The set of known {@link Source}s.
*/
private final Set<Source> sources = Sets.newHashSet();
private int currentContextId;
private String currentNodeName;
private int currentNodeNameId;
private IndexNode currentNode;
public SplitIndexStoreImpl(NodeManager nodeManager) {
this.nodeManager = nodeManager;
this.contextCodec = nodeManager.getContextCodec();
this.elementCodec = nodeManager.getElementCodec();
this.stringCodec = nodeManager.getStringCodec();
}
@Override
public boolean aboutToIndexDart(AnalysisContext context, CompilationUnitElement unitElement) {
context = unwrapContext(context);
// may be already disposed in other thread
if (context.isDisposed()) {
return false;
}
// validate unit
if (unitElement == null) {
return false;
}
LibraryElement libraryElement = unitElement.getLibrary();
if (libraryElement == null) {
return false;
}
CompilationUnitElement definingUnitElement = libraryElement.getDefiningCompilationUnit();
if (definingUnitElement == null) {
return false;
}
// prepare sources
Source library = definingUnitElement.getSource();
Source unit = unitElement.getSource();
// special handling for the defining library unit
if (unit.equals(library)) {
// prepare new parts
Set<Source> newParts = Sets.newHashSet();
for (CompilationUnitElement part : libraryElement.getParts()) {
newParts.add(part.getSource());
}
// prepare old parts
Map<Source, Set<Source>> libraryToUnits = contextToLibraryToUnits.get(context);
if (libraryToUnits == null) {
libraryToUnits = Maps.newHashMap();
contextToLibraryToUnits.put(context, libraryToUnits);
}
Set<Source> oldParts = libraryToUnits.get(library);
// check if some parts are not in the library now
if (oldParts != null) {
Set<Source> noParts = Sets.difference(oldParts, newParts);
for (Source noPart : noParts) {
removeLocations(context, library, noPart);
}
}
// remember new parts
libraryToUnits.put(library, newParts);
}
// remember library/unit relations
recordUnitInLibrary(context, library, unit);
recordLibraryWithUnit(context, library, unit);
sources.add(library);
sources.add(unit);
// prepare node
String libraryName = library.getFullName();
String unitName = unit.getFullName();
int libraryNameIndex = stringCodec.encode(libraryName);
int unitNameIndex = stringCodec.encode(unitName);
currentNodeName = libraryNameIndex + "_" + unitNameIndex + ".index";
currentNodeNameId = stringCodec.encode(currentNodeName);
currentNode = nodeManager.newNode(context);
currentContextId = contextCodec.encode(context);
// remove Universe information for the current node
for (Map<Integer, ?> nodeRelations : contextNodeRelations.values()) {
nodeRelations.remove(currentNodeNameId);
}
// done
return true;
}
@Override
public boolean aboutToIndexHtml(AnalysisContext context, HtmlElement htmlElement) {
context = unwrapContext(context);
// may be already disposed in other thread
if (context.isDisposed()) {
return false;
}
// remove locations
Source source = htmlElement.getSource();
removeLocations(context, null, source);
// remember library/unit relations
recordUnitInLibrary(context, null, source);
// prepare node
String sourceName = source.getFullName();
int sourceNameIndex = stringCodec.encode(sourceName);
currentNodeName = sourceNameIndex + ".index";
currentNodeNameId = stringCodec.encode(currentNodeName);
currentNode = nodeManager.newNode(context);
return true;
}
@Override
public void clear() {
nodeManager.clear();
elementToNodeNames.clear();
}
@Override
public void doneIndex() {
if (currentNode != null) {
nodeManager.putNode(currentNodeName, currentNode);
currentNodeName = null;
currentNodeNameId = -1;
currentNode = null;
currentContextId = -1;
}
}
@Override
public Location[] getRelationships(Element element, Relationship relationship) {
// special support for UniverseElement
if (element == UniverseElement.INSTANCE) {
return getRelationshipsUniverse(relationship);
}
// prepare node names
int elementId = elementCodec.encodeHash(element);
int[] nodeNameIds = elementToNodeNames.get(elementId);
// check each node
List<Location> locations = Lists.newArrayList();
for (int i = 0; i < nodeNameIds.length; i++) {
int nodeNameId = nodeNameIds[i];
String nodeName = stringCodec.decode(nodeNameId);
IndexNode node = nodeManager.getNode(nodeName);
if (node != null) {
Collections.addAll(locations, node.getRelationships(element, relationship));
} else {
nodeNameIds = ArrayUtils.removeElement(nodeNameIds, nodeNameId);
i--;
}
}
// done
return locations.toArray(new Location[locations.size()]);
}
@Override
public String getStatistics() {
return "[" + nodeManager.getLocationCount() + " locations, " + sources.size() + " sources, "
+ elementToNodeNames.size() + " elements]";
}
@Override
public void recordRelationship(Element element, Relationship relationship, Location location) {
if (element == null || element.getKind() == ElementKind.ERROR) {
return;
}
if (location == null) {
return;
}
// special support for UniverseElement
if (element == UniverseElement.INSTANCE) {
recordRelationshipUniverse(relationship, location);
return;
}
// other elements
recordNodeNameForElement(element);
currentNode.recordRelationship(element, relationship, location);
}
@Override
public void removeContext(AnalysisContext context) {
context = unwrapContext(context);
if (context == null) {
return;
}
// remove sources
removeSources(context, null);
// remove context information
contextToLibraryToUnits.remove(context);
contextToUnitToLibraries.remove(context);
contextNodeRelations.remove(contextCodec.encode(context));
// remove context from codec
contextCodec.removeContext(context);
}
@Override
public void removeSource(AnalysisContext context, Source source) {
context = unwrapContext(context);
if (context == null) {
return;
}
// remove nodes for unit/library pairs
Map<Source, Set<Source>> unitToLibraries = contextToUnitToLibraries.get(context);
if (unitToLibraries != null) {
Set<Source> libraries = unitToLibraries.remove(source);
if (libraries != null) {
for (Source library : libraries) {
removeLocations(context, library, source);
}
}
}
// remove nodes for library/unit pairs
Map<Source, Set<Source>> libraryToUnits = contextToLibraryToUnits.get(context);
if (libraryToUnits != null) {
Set<Source> units = libraryToUnits.remove(source);
if (units != null) {
for (Source unit : units) {
removeLocations(context, source, unit);
}
}
}
}
@Override
public void removeSources(AnalysisContext context, SourceContainer container) {
context = unwrapContext(context);
if (context == null) {
return;
}
// remove nodes for unit/library pairs
Map<Source, Set<Source>> unitToLibraries = contextToUnitToLibraries.get(context);
if (unitToLibraries != null) {
List<Source> units = Lists.newArrayList(unitToLibraries.keySet());
for (Source source : units) {
if (container == null || container.contains(source)) {
removeSource(context, source);
}
}
}
// remove nodes for library/unit pairs
Map<Source, Set<Source>> libraryToUnits = contextToLibraryToUnits.get(context);
if (libraryToUnits != null) {
List<Source> libraries = Lists.newArrayList(libraryToUnits.keySet());
for (Source source : libraries) {
if (container == null || container.contains(source)) {
removeSource(context, source);
}
}
}
}
private Location[] getRelationshipsUniverse(Relationship relationship) {
List<Location> locations = Lists.newArrayList();
for (Entry<Integer, Map<Integer, Map<Relationship, List<LocationData>>>> contextEntry : contextNodeRelations.entrySet()) {
int contextId = contextEntry.getKey();
AnalysisContext context = contextCodec.decode(contextId);
if (context != null) {
for (Map<Relationship, List<LocationData>> nodeRelations : contextEntry.getValue().values()) {
List<LocationData> nodeLocations = nodeRelations.get(relationship);
if (nodeLocations != null) {
for (LocationData locationData : nodeLocations) {
Location location = locationData.getLocation(context, elementCodec);
if (location != null) {
locations.add(location);
}
}
}
}
}
}
return locations.toArray(new Location[locations.size()]);
}
private void recordLibraryWithUnit(AnalysisContext context, Source library, Source unit) {
Map<Source, Set<Source>> libraryToUnits = contextToLibraryToUnits.get(context);
if (libraryToUnits == null) {
libraryToUnits = Maps.newHashMap();
contextToLibraryToUnits.put(context, libraryToUnits);
}
Set<Source> units = libraryToUnits.get(library);
if (units == null) {
units = Sets.newHashSet();
libraryToUnits.put(library, units);
}
units.add(unit);
}
private void recordNodeNameForElement(Element element) {
int elementId = elementCodec.encodeHash(element);
elementToNodeNames.add(elementId, currentNodeNameId);
}
private void recordRelationshipUniverse(Relationship relationship, Location location) {
// in current context
Map<Integer, Map<Relationship, List<LocationData>>> nodeRelations = contextNodeRelations.get(currentContextId);
if (nodeRelations == null) {
nodeRelations = Maps.newHashMap();
contextNodeRelations.put(currentContextId, nodeRelations);
}
// in current node
Map<Relationship, List<LocationData>> relations = nodeRelations.get(currentNodeNameId);
if (relations == null) {
relations = Maps.newHashMap();
nodeRelations.put(currentNodeNameId, relations);
}
// for the given relationship
List<LocationData> locations = relations.get(relationship);
if (locations == null) {
locations = Lists.newArrayList();
relations.put(relationship, locations);
}
// record LocationData
locations.add(new LocationData(elementCodec, location));
}
private void recordUnitInLibrary(AnalysisContext context, Source library, Source unit) {
Map<Source, Set<Source>> unitToLibraries = contextToUnitToLibraries.get(context);
if (unitToLibraries == null) {
unitToLibraries = Maps.newHashMap();
contextToUnitToLibraries.put(context, unitToLibraries);
}
Set<Source> libraries = unitToLibraries.get(unit);
if (libraries == null) {
libraries = Sets.newHashSet();
unitToLibraries.put(unit, libraries);
}
libraries.add(library);
}
/**
* Removes locations recorded in the given library/unit pair.
*/
private void removeLocations(AnalysisContext context, Source library, Source unit) {
// remove node
String libraryName = library != null ? library.getFullName() : null;
String unitName = unit.getFullName();
int libraryNameIndex = stringCodec.encode(libraryName);
int unitNameIndex = stringCodec.encode(unitName);
String nodeName = libraryNameIndex + "_" + unitNameIndex + ".index";
nodeManager.removeNode(nodeName);
// remove source
sources.remove(library);
sources.remove(unit);
}
/**
* When logging is on, {@link AnalysisEngine} actually creates
* {@link InstrumentedAnalysisContextImpl}, which wraps {@link AnalysisContextImpl} used to create
* actual {@link Element}s. So, in index we have to unwrap {@link InstrumentedAnalysisContextImpl}
* when perform any operation.
*/
private AnalysisContext unwrapContext(AnalysisContext context) {
if (context instanceof InstrumentedAnalysisContextImpl) {
context = ((InstrumentedAnalysisContextImpl) context).getBasis();
}
return context;
}
}