Tweaks for review comments.

pkg/analysis_server/lib/src/index/page_node_manager.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.page_node_manager;
 
 import 'dart:collection';
 import 'dart:typed_data';
 
 import 'package:analysis_server/src/index/lru_cache.dart';
@@ skipping 166 matching lines @@
       throw new StateError('Page $id has been already freed.');
     }
   }
 
   @override
   Uint8List read(int id) {
     Uint8List page = _pages[id];
     if (page == null) {
       throw new StateError('Page $id does not exist.');
     }
     return page;

[Paul Berry, 2014/06/10 20:23:40]

If the client is allowed to modify the page, then read() must make a copy.

[scheglov, 2014/06/10 20:36:55]

Done.

   }
 
   @override
   void write(int id, Uint8List page) {
     if (!_pages.containsKey(id)) {
       throw new StateError('Page $id does not exist.');
     }
+    if (page.length != pageSizeInBytes) {
+      throw new ArgumentError('Page $id has length ${page.length}, '
+          'but $pageSizeInBytes is expected.');
+    }
     _pages[id] = page;
   }
 }
 
 
 /**
  * [PageManager] allows to allocate, read, write and free [Uint8List] pages.
  */
 abstract class PageManager {
   /**
    * The size of pages provided by this [PageManager].
    */
   int get pageSizeInBytes;
 
   /**
    * Allocates a new page and returns its identifier.
    */
   int alloc();
 
   /**
    * Frees the page with the given identifier.
    */
   void free(int id);
 
   /**
    * Reads the page with the given identifier and returns its content.
+   * The client may modify this page and [write] it later.
    */
   Uint8List read(int id);
 
   /**
    * Writes the given page.
    */
   void write(int id, Uint8List page);
 }
 
 
 /**
  * A [NodeManager] that keeps nodes in [PageManager].
  */
 class PageNodeManager<K, V> implements NodeManager<K, V, int> {
-  static const int INDEX_OFFSET_DATA = 4;
-  static const int INDEX_OFFSET_KEY_COUNT = 0;
-  static const int LEAF_OFFSET_DATA = 4;
-  static const int LEAF_OFFSET_KEY_COUNT = 0;
+  static const int _INDEX_OFFSET_DATA = 4;
+  static const int _INDEX_OFFSET_KEY_COUNT = 0;
+  static const int _LEAF_OFFSET_DATA = 4;
+  static const int _LEAF_OFFSET_KEY_COUNT = 0;
 
   final Set<int> _indexPages = new HashSet<int>();
   Codec<K> _keyCodec;
   final Set<int> _leafPages = new HashSet<int>();
   PageManager _pageManager;
   Codec<V> _valueCodec;
 
   PageNodeManager(this._pageManager, this._keyCodec, this._valueCodec);
 
   @override
   int get maxIndexKeys {
     int keySize = _keyCodec.sizeInBytes;
     int childSize = 4;
-    int dataSize = _pageManager.pageSizeInBytes - INDEX_OFFSET_DATA;
+    int dataSize = _pageManager.pageSizeInBytes - _INDEX_OFFSET_DATA;
     return (dataSize - childSize) ~/ (keySize + childSize);
   }
 
   @override
   int get maxLeafKeys {
     int keySize = _keyCodec.sizeInBytes;
     int valueSize = _valueCodec.sizeInBytes;
-    int dataSize = _pageManager.pageSizeInBytes - INDEX_OFFSET_DATA;
+    int dataSize = _pageManager.pageSizeInBytes - _INDEX_OFFSET_DATA;
     return dataSize ~/ (keySize + valueSize);
   }
 
   @override
   int createIndex() {
     int id = _pageManager.alloc();
     _indexPages.add(id);
     return id;
   }
 
@@ skipping 16 matching lines @@
     return _indexPages.contains(id);
   }
 
   @override
   IndexNodeData<K, int> readIndex(int id) {
     Uint8List page = _pageManager.read(id);
     // read header
     int keyCount;
     {
       ByteData data = new ByteData.view(page.buffer);
-      keyCount = data.getInt32(INDEX_OFFSET_KEY_COUNT);
+      keyCount = data.getInt32(_INDEX_OFFSET_KEY_COUNT);
     }
     // read keys/children
     List<K> keys = new List<K>();
     List<int> children = new List<int>();
     int keySize = _keyCodec.sizeInBytes;
-    int offset = INDEX_OFFSET_DATA;
+    int offset = _INDEX_OFFSET_DATA;
     for (int i = 0; i < keyCount; i++) {
       // read child
       {
         ByteData byteData = new ByteData.view(page.buffer, offset);
         int childPage = byteData.getUint32(0);
         children.add(childPage);
         offset += 4;
       }
       // read key
       {
@@ skipping 13 matching lines @@
     return new IndexNodeData<K, int>(keys, children);
   }
 
   @override
   LeafNodeData<K, V> readLeaf(int id) {
     Uint8List page = _pageManager.read(id);
     // read header
     int keyCount;
     {
       ByteData data = new ByteData.view(page.buffer);
-      keyCount = data.getInt32(LEAF_OFFSET_KEY_COUNT);
+      keyCount = data.getInt32(_LEAF_OFFSET_KEY_COUNT);
     }
     // read keys/children
     List<K> keys = new List<K>();
     List<V> values = new List<V>();
     int keySize = _keyCodec.sizeInBytes;
     int valueSize = _valueCodec.sizeInBytes;
-    int offset = LEAF_OFFSET_DATA;
+    int offset = _LEAF_OFFSET_DATA;
     for (int i = 0; i < keyCount; i++) {
       // read key
       {
         ByteData byteData = new ByteData.view(page.buffer, offset, keySize);
         K key = _keyCodec.decode(byteData);
         keys.add(key);
         offset += keySize;
       }
       // read value
       {
         ByteData byteData = new ByteData.view(page.buffer, offset);
         V value = _valueCodec.decode(byteData);
         values.add(value);
         offset += valueSize;
       }
     }
     // done
     return new LeafNodeData<K, V>(keys, values);
   }
 
   @override
   void writeIndex(int id, IndexNodeData<K, int> data) {
     Uint8List page = new Uint8List(_pageManager.pageSizeInBytes);
     // write header
     int keyCount = data.keys.length;
     {
       ByteData byteData = new ByteData.view(page.buffer);
-      byteData.setUint32(PageNodeManager.INDEX_OFFSET_KEY_COUNT, keyCount);
+      byteData.setUint32(PageNodeManager._INDEX_OFFSET_KEY_COUNT, keyCount);
     }
     // write keys/children
     int keySize = _keyCodec.sizeInBytes;
-    int offset = PageNodeManager.INDEX_OFFSET_DATA;
+    int offset = PageNodeManager._INDEX_OFFSET_DATA;
     for (int i = 0; i < keyCount; i++) {
       // write child
       {
         ByteData byteData = new ByteData.view(page.buffer, offset);
         byteData.setUint32(0, data.children[i]);
         offset += 4;
       }
       // write key
       {
         ByteData byteData = new ByteData.view(page.buffer, offset, keySize);
@@ skipping 10 matching lines @@
     _pageManager.write(id, page);
   }
 
   @override
   void writeLeaf(int id, LeafNodeData<K, V> data) {
     Uint8List page = new Uint8List(_pageManager.pageSizeInBytes);
     // write header
     int keyCount = data.keys.length;
     {
       ByteData byteData = new ByteData.view(page.buffer);
-      byteData.setUint32(PageNodeManager.LEAF_OFFSET_KEY_COUNT, keyCount);
+      byteData.setUint32(PageNodeManager._LEAF_OFFSET_KEY_COUNT, keyCount);
     }
     // write keys/values
     int keySize = _keyCodec.sizeInBytes;
     int valueSize = _valueCodec.sizeInBytes;
-    int offset = PageNodeManager.LEAF_OFFSET_DATA;
+    int offset = PageNodeManager._LEAF_OFFSET_DATA;
     for (int i = 0; i < keyCount; i++) {
       // write key
       {
         ByteData byteData = new ByteData.view(page.buffer, offset, keySize);
         _keyCodec.encode(byteData, data.keys[i]);
         offset += keySize;
       }
       // write value
       {
         ByteData byteData = new ByteData.view(page.buffer, offset);
@@ skipping 21 matching lines @@
   @override
   int decode(ByteData buffer) {
     return buffer.getUint32(0);
   }
 
   @override
   void encode(ByteData buffer, int element) {
     buffer.setUint32(0, element);
   }
 }