dart/editor/tools/plugins/com.google.dart.engine/src/com/google/dart/engine/internal/index/file/SplitIndexStoreImpl.java - external/dart - Git at Google

 /*
  * 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;
   }
 }
	/*
	* 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;
	}
	}