Use BufferContext + offset instead of BufferPointer.

pkg/analyzer/test/src/summary/flat_buffers_test.dart

 // Copyright (c) 2016, 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 test.src.summary.flat_buffers_test;
 
 import 'dart:typed_data';
 
 import 'package:analyzer/src/summary/flat_buffers.dart';
 import 'package:unittest/unittest.dart';
@@ skipping 91 matching lines @@
     List<int> byteList;
     {
       Builder builder = new Builder(initialSize: 0);
       builder.startTable();
       builder.addInt32(0, 10, 10);
       builder.addInt32(1, 20, 10);
       Offset offset = builder.endTable();
       byteList = builder.finish(offset);
     }
     // read and verify
-    BufferPointer object = new BufferPointer.fromBytes(byteList).derefObject();
+    BufferContext buffer = new BufferContext.fromBytes(byteList);
+    int objectOffset = buffer.derefObject(0);
     // was not written, so uses the new default value
-    expect(const Int32Reader().vTableGet(object, 0, 15), 15);
+    expect(const Int32Reader().vTableGet(buffer, objectOffset, 0, 15), 15);
     // has the written value
-    expect(const Int32Reader().vTableGet(object, 1, 15), 20);
+    expect(const Int32Reader().vTableGet(buffer, objectOffset, 1, 15), 20);
   }
 
   void test_table_format() {
     Uint8List byteList;
     {
       Builder builder = new Builder(initialSize: 0);
       builder.startTable();
       builder.addInt32(0, 10);
       builder.addInt32(1, 20);
       builder.addInt32(2, 30);
@@ skipping 30 matching lines @@
       Builder builder = new Builder(initialSize: 0);
       Offset<String> latinStringOffset = builder.writeString(latinString);
       Offset<String> unicodeStringOffset = builder.writeString(unicodeString);
       builder.startTable();
       builder.addOffset(0, latinStringOffset);
       builder.addOffset(1, unicodeStringOffset);
       Offset offset = builder.endTable();
       byteList = builder.finish(offset);
     }
     // read and verify
-    BufferPointer object = new BufferPointer.fromBytes(byteList).derefObject();
-    expect(const StringReader().vTableGet(object, 0), latinString);
-    expect(const StringReader().vTableGet(object, 1), unicodeString);
+    BufferContext buf = new BufferContext.fromBytes(byteList);
+    int objectOffset = buf.derefObject(0);
+    expect(const StringReader().vTableGet(buf, objectOffset, 0), latinString);
+    expect(const StringReader().vTableGet(buf, objectOffset, 1), unicodeString);
   }
 
   void test_table_types() {
     List<int> byteList;
     {
       Builder builder = new Builder(initialSize: 0);
       Offset<String> stringOffset = builder.writeString('12345');
       builder.startTable();
       builder.addBool(0, true);
       builder.addInt8(1, 10);
       builder.addInt32(2, 20);
       builder.addOffset(3, stringOffset);
       builder.addInt32(4, 40);
       builder.addUint32(5, 0x9ABCDEF0);
       builder.addUint8(6, 0x9A);
       Offset offset = builder.endTable();
       byteList = builder.finish(offset);
     }
     // read and verify
-    BufferPointer object = new BufferPointer.fromBytes(byteList).derefObject();
-    expect(const BoolReader().vTableGet(object, 0), true);
-    expect(const Int8Reader().vTableGet(object, 1), 10);
-    expect(const Int32Reader().vTableGet(object, 2), 20);
-    expect(const StringReader().vTableGet(object, 3), '12345');
-    expect(const Int32Reader().vTableGet(object, 4), 40);
-    expect(const Uint32Reader().vTableGet(object, 5), 0x9ABCDEF0);
-    expect(const Uint8Reader().vTableGet(object, 6), 0x9A);
+    BufferContext buf = new BufferContext.fromBytes(byteList);
+    int objectOffset = buf.derefObject(0);
+    expect(const BoolReader().vTableGet(buf, objectOffset, 0), true);
+    expect(const Int8Reader().vTableGet(buf, objectOffset, 1), 10);
+    expect(const Int32Reader().vTableGet(buf, objectOffset, 2), 20);
+    expect(const StringReader().vTableGet(buf, objectOffset, 3), '12345');
+    expect(const Int32Reader().vTableGet(buf, objectOffset, 4), 40);
+    expect(const Uint32Reader().vTableGet(buf, objectOffset, 5), 0x9ABCDEF0);
+    expect(const Uint8Reader().vTableGet(buf, objectOffset, 6), 0x9A);
   }
 
   void test_writeList_of_Uint32() {
     List<int> values = <int>[10, 100, 12345, 0x9abcdef0];
     // write
     List<int> byteList;
     {
       Builder builder = new Builder(initialSize: 0);
       Offset offset = builder.writeListUint32(values);
       byteList = builder.finish(offset);
     }
     // read and verify
-    BufferPointer root = new BufferPointer.fromBytes(byteList);
-    List<int> items = const Uint32ListReader().read(root);
+    BufferContext buf = new BufferContext.fromBytes(byteList);
+    List<int> items = const Uint32ListReader().read(buf, 0);
     expect(items, hasLength(4));
     expect(items, orderedEquals(values));
   }
 
   void test_writeList_ofBool() {
     void verifyListBooleans(int len, List<int> trueBits) {
       // write
       List<int> byteList;
       {
         Builder builder = new Builder(initialSize: 0);
         List<bool> values = new List<bool>.filled(len, false);
         for (int bit in trueBits) {
           values[bit] = true;
         }
         Offset offset = builder.writeListBool(values);
         byteList = builder.finish(offset);
       }
       // read and verify
-      BufferPointer root = new BufferPointer.fromBytes(byteList);
-      List<bool> items = const BoolListReader().read(root);
+      BufferContext buf = new BufferContext.fromBytes(byteList);
+      List<bool> items = const BoolListReader().read(buf, 0);
       expect(items, hasLength(len));
       for (int i = 0; i < items.length; i++) {
         expect(items[i], trueBits.contains(i), reason: 'bit $i of $len');
       }
     }
     verifyListBooleans(0, <int>[]);
     verifyListBooleans(1, <int>[]);
     verifyListBooleans(1, <int>[0]);
     verifyListBooleans(31, <int>[0, 1]);
     verifyListBooleans(31, <int>[1, 2, 24, 25, 30]);
@@ skipping 15 matching lines @@
   void test_writeList_ofFloat64() {
     List<double> values = <double>[-1.234567, 3.4E+9, -5.6E-13, 7.8, 12.13];
     // write
     List<int> byteList;
     {
       Builder builder = new Builder(initialSize: 0);
       Offset offset = builder.writeListFloat64(values);
       byteList = builder.finish(offset);
     }
     // read and verify
-    BufferPointer root = new BufferPointer.fromBytes(byteList);
-    List<double> items = const Float64ListReader().read(root);
+    BufferContext buf = new BufferContext.fromBytes(byteList);
+    List<double> items = const Float64ListReader().read(buf, 0);
     expect(items, hasLength(5));
     expect(items, orderedEquals(values));
   }
 
   void test_writeList_ofInt32() {
     List<int> byteList;
     {
       Builder builder = new Builder(initialSize: 0);
       Offset offset = builder.writeListInt32(<int>[1, 2, 3, 4, 5]);
       byteList = builder.finish(offset);
     }
     // read and verify
-    BufferPointer root = new BufferPointer.fromBytes(byteList);
-    List<int> items = const ListReader<int>(const Int32Reader()).read(root);
+    BufferContext buf = new BufferContext.fromBytes(byteList);
+    List<int> items = const ListReader<int>(const Int32Reader()).read(buf, 0);
     expect(items, hasLength(5));
     expect(items, orderedEquals(<int>[1, 2, 3, 4, 5]));
   }
 
   void test_writeList_ofObjects() {
     List<int> byteList;
     {
       Builder builder = new Builder(initialSize: 0);
       // write the object #1
       Offset object1;
       {
         builder.startTable();
         builder.addInt32(0, 10);
         builder.addInt32(1, 20);
         object1 = builder.endTable();
       }
       // write the object #1
       Offset object2;
       {
         builder.startTable();
         builder.addInt32(0, 100);
         builder.addInt32(1, 200);
         object2 = builder.endTable();
       }
       // write the list
       Offset offset = builder.writeList([object1, object2]);
       byteList = builder.finish(offset);
     }
     // read and verify
-    BufferPointer root = new BufferPointer.fromBytes(byteList);
+    BufferContext buf = new BufferContext.fromBytes(byteList);
     List<TestPointImpl> items =
-        const ListReader<TestPointImpl>(const TestPointReader()).read(root);
+        const ListReader<TestPointImpl>(const TestPointReader()).read(buf, 0);
     expect(items, hasLength(2));
     expect(items[0].x, 10);
     expect(items[0].y, 20);
     expect(items[1].x, 100);
     expect(items[1].y, 200);
   }
 
   void test_writeList_ofStrings_asRoot() {
     List<int> byteList;
     {
       Builder builder = new Builder(initialSize: 0);
       Offset<String> str1 = builder.writeString('12345');
       Offset<String> str2 = builder.writeString('ABC');
       Offset offset = builder.writeList([str1, str2]);
       byteList = builder.finish(offset);
     }
     // read and verify
-    BufferPointer root = new BufferPointer.fromBytes(byteList);
+    BufferContext buf = new BufferContext.fromBytes(byteList);
     List<String> items =
-        const ListReader<String>(const StringReader()).read(root);
+        const ListReader<String>(const StringReader()).read(buf, 0);
     expect(items, hasLength(2));
     expect(items, contains('12345'));
     expect(items, contains('ABC'));
   }
 
   void test_writeList_ofStrings_inObject() {
     List<int> byteList;
     {
       Builder builder = new Builder(initialSize: 0);
       Offset listOffset = builder.writeList(
           [builder.writeString('12345'), builder.writeString('ABC')]);
       builder.startTable();
       builder.addOffset(0, listOffset);
       Offset offset = builder.endTable();
       byteList = builder.finish(offset);
     }
     // read and verify
-    BufferPointer root = new BufferPointer.fromBytes(byteList);
-    StringListWrapperImpl reader = new StringListWrapperReader().read(root);
+    BufferContext buf = new BufferContext.fromBytes(byteList);
+    StringListWrapperImpl reader = new StringListWrapperReader().read(buf, 0);
     List<String> items = reader.items;
     expect(items, hasLength(2));
     expect(items, contains('12345'));
     expect(items, contains('ABC'));
   }
 
   void test_writeList_ofUint32() {
     List<int> byteList;
     {
       Builder builder = new Builder(initialSize: 0);
       Offset offset = builder.writeListUint32(<int>[1, 2, 0x9ABCDEF0]);
       byteList = builder.finish(offset);
     }
     // read and verify
-    BufferPointer root = new BufferPointer.fromBytes(byteList);
-    List<int> items = const Uint32ListReader().read(root);
+    BufferContext buf = new BufferContext.fromBytes(byteList);
+    List<int> items = const Uint32ListReader().read(buf, 0);
     expect(items, hasLength(3));
     expect(items, orderedEquals(<int>[1, 2, 0x9ABCDEF0]));
   }
 
   void test_writeList_ofUint8() {
     List<int> byteList;
     {
       Builder builder = new Builder(initialSize: 0);
       Offset offset = builder.writeListUint8(<int>[1, 2, 3, 4, 0x9A]);
       byteList = builder.finish(offset);
     }
     // read and verify
-    BufferPointer root = new BufferPointer.fromBytes(byteList);
-    List<int> items = const Uint8ListReader().read(root);
+    BufferContext buf = new BufferContext.fromBytes(byteList);
+    List<int> items = const Uint8ListReader().read(buf, 0);
     expect(items, hasLength(5));
     expect(items, orderedEquals(<int>[1, 2, 3, 4, 0x9A]));
   }
 }
 
 class StringListWrapperImpl {
-  final BufferPointer bp;
+  final BufferContext bp;
+  final int offset;
 
-  StringListWrapperImpl(this.bp);
+  StringListWrapperImpl(this.bp, this.offset);
 
   List<String> get items =>
-      const ListReader<String>(const StringReader()).vTableGet(bp, 0);
+      const ListReader<String>(const StringReader()).vTableGet(bp, offset, 0);
 }
 
 class StringListWrapperReader extends TableReader<StringListWrapperImpl> {
   const StringListWrapperReader();
 
   @override
-  StringListWrapperImpl createObject(BufferPointer object) {
-    return new StringListWrapperImpl(object);
+  StringListWrapperImpl createObject(BufferContext object, int offset) {
+    return new StringListWrapperImpl(object, offset);
   }
 }
 
 class TestPointImpl {
-  final BufferPointer bp;
+  final BufferContext bp;
+  final int offset;
 
-  TestPointImpl(this.bp);
+  TestPointImpl(this.bp, this.offset);
 
-  int get x => const Int32Reader().vTableGet(bp, 0, 0);
+  int get x => const Int32Reader().vTableGet(bp, offset, 0, 0);
 
-  int get y => const Int32Reader().vTableGet(bp, 1, 0);
+  int get y => const Int32Reader().vTableGet(bp, offset, 1, 0);
 }
 
 class TestPointReader extends TableReader<TestPointImpl> {
   const TestPointReader();
 
   @override
-  TestPointImpl createObject(BufferPointer object) {
-    return new TestPointImpl(object);
+  TestPointImpl createObject(BufferContext object, int offset) {
+    return new TestPointImpl(object, offset);
   }
 }