Move Index and IndexStore implementations into Engine.

pkg/analyzer/lib/src/index/store/split_store.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-library index.split_store;
+library engine.src.index.split_store;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:io';
 import 'dart:typed_data';
 
-import 'package:analysis_server/src/index/store/collection.dart';
+import 'package:analyzer/index/index.dart';
+import 'package:analyzer/index/index_store.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
-import 'package:analyzer/src/generated/index.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/source.dart';
-import 'package:analysis_server/src/index/store/codec.dart';
+import 'package:analyzer/src/index/store/codec.dart';
+import 'package:analyzer/src/index/store/collection.dart';
 
 
 /**
  * A manager for files content.
  */
 abstract class FileManager {
   /**
    * Removes all files.
    */
   void clear();
@@ skipping 14 matching lines @@
   Future write(String name, List<int> bytes);
 }
 
 
 /**
  * A [FileManager] based [NodeManager].
  */
 class FileNodeManager implements NodeManager {
   static int _VERSION = 1;
 
+  final FileManager _fileManager;
+  final Logger _logger;
+
   final ContextCodec contextCodec;
-
   final ElementCodec elementCodec;
-
   final StringCodec stringCodec;
-
-  final FileManager _fileManager;
+  final RelationshipCodec _relationshipCodec;
 
   int _locationCount = 0;
 
-  final Logger _logger;
-
   Map<String, int> _nodeLocationCounts = new HashMap<String, int>();
 
-  final RelationshipCodec _relationshipCodec;
-
   FileNodeManager(this._fileManager, this._logger, this.stringCodec,
       this.contextCodec, this.elementCodec, this._relationshipCodec);
 
   @override
   int get locationCount => _locationCount;
 
   @override
   void clear() {
     _fileManager.clear();
   }
@@ skipping 128 matching lines @@
 }
 
 
 /**
  * A single index file in-memory presentation.
  */
 class IndexNode {
   final AnalysisContext context;
 
   final ElementCodec _elementCodec;
+  final RelationshipCodec _relationshipCodec;
 
   Map<RelationKeyData, List<LocationData>> _relations =
       new HashMap<RelationKeyData, List<LocationData>>();
 
-  final RelationshipCodec _relationshipCodec;
 
   IndexNode(this.context, this._elementCodec, this._relationshipCodec);
 
   /**
    * Returns number of locations in this node.
    */
   int get locationCount {
     int locationCount = 0;
     for (List<LocationData> locations in _relations.values) {
       locationCount += locations.length;
     }
     return locationCount;
   }
 
   /**
    * Returns the recorded relations.
    */
   Map<RelationKeyData, List<LocationData>> get relations => _relations;
 
   /**
-   * Sets relations data. This method is used during loading data from a storage.
+   * Sets relations data.
+   * This method is used during loading data from a storage.
    */
   void set relations(Map<RelationKeyData, List<LocationData>> relations) {
-    this._relations.clear();
-    this._relations.addAll(relations);
+    _relations = relations;
   }
 
   /**
-   * Return the locations of the elements that have the given relationship with the given element.
+   * Returns the locations of the elements that have the given relationship with
+   * the given element.
    *
-   * @param element the the element that has the relationship with the locations to be returned
-   * @param relationship the [Relationship] between the given element and the locations to be
-   *          returned
+   * [element] - the the element that has the relationship with the locations to
+   *    be returned.
+   * [relationship] - the [Relationship] between the given [element] and the
+   *    locations to be returned
    */
   List<Location> getRelationships(Element element, Relationship relationship) {
     // prepare key
     RelationKeyData key = new RelationKeyData.forObject(_elementCodec,
         _relationshipCodec, element, relationship);
     // find LocationData(s)
     List<LocationData> locationDatas = _relations[key];
     if (locationDatas == null) {
       return Location.EMPTY_ARRAY;
     }
     // convert to Location(s)
     List<Location> locations = <Location>[];
     for (LocationData locationData in locationDatas) {
       Location location = locationData.getLocation(context, _elementCodec);
       if (location != null) {
         locations.add(location);
       }
     }
     return locations;
   }
 
   /**
-   * Records that the given element and location have the given relationship.
+   * Records that the given [element] and [location] have the given [relationship].
    *
-   * @param element the element that is related to the location
-   * @param relationship the [Relationship] between the element and the location
-   * @param location the [Location] where relationship happens
+   * [element] - the [Element] that is related to the location.
+   * [relationship] - the [Relationship] between [element] and [location].
+   * [location] - the [Location] where relationship happens.
    */
   void recordRelationship(Element element, Relationship relationship,
       Location location) {
     RelationKeyData key = new RelationKeyData.forObject(_elementCodec,
         _relationshipCodec, element, relationship);
     // prepare LocationData(s)
     List<LocationData> locationDatas = _relations[key];
     if (locationDatas == null) {
       locationDatas = <LocationData>[];
       _relations[key] = locationDatas;
     }
     // add new LocationData
     locationDatas.add(new LocationData.forObject(_elementCodec, location));
   }
 }
 
 
 /**
  * A container with information about a [Location].
  */
 class LocationData {
   final int elementId;
+  final int offset;
   final int length;
-  final int offset;
 
   LocationData.forData(this.elementId, this.offset, this.length);
 
   LocationData.forObject(ElementCodec elementCodec, Location location)
       : elementId = elementCodec.encode(location.element),
         offset = location.offset,
         length = location.length;
 
   @override
   int get hashCode {
@@ skipping 283 matching lines @@
   void doneIndex() {
     if (_currentNode != null) {
       _nodeManager.putNode(_currentNodeName, _currentNode);
       _currentNodeName = null;
       _currentNodeNameId = -1;
       _currentNode = null;
       _currentContextId = -1;
     }
   }
 
-  @override
-  List<Location> getRelationships(Element element, Relationship relationship) {
-    // TODO(scheglov) make IndexStore interface async
-    return <Location>[];
-  }
-
-  Future<List<Location>> getRelationshipsAsync(Element element,
+  Future<List<Location>> getRelationships(Element element,
       Relationship relationship) {
     // special support for UniverseElement
     if (identical(element, UniverseElement.INSTANCE)) {
       List<Location> locations = _getRelationshipsUniverse(relationship);
       return new Future.value(locations);
     }
     // prepare node names
     String name = _getElementName(element);
     int nameId = _stringCodec.encode(name);
     List<int> nodeNameIds = _nameToNodeNames.get(nameId);
@@ skipping 263 matching lines @@
     return new Uint8List.fromList(_buffer.takeBytes());
   }
 
   void writeInt(int value) {
     _buffer.addByte((value & 0xFF000000) >> 24);
     _buffer.addByte((value & 0x00FF0000) >> 16);
     _buffer.addByte((value & 0x0000FF00) >> 8);
     _buffer.addByte(value & 0xFF);
   }
 }