Write and read support for Float64 lists in FlatBuffers.

pkg/analyzer/lib/src/summary/flat_buffers.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 analyzer.src.summary.flat_buffers;
 
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:math';
 import 'dart:typed_data';
@@ skipping 31 matching lines @@
     return _advance(uOffset);
   }
 
   @override
   String toString() => _offset.toString();
 
   BufferPointer _advance(int delta) {
     return new BufferPointer._(_buffer, _offset + delta);
   }
 
+  double _getFloat64([int delta = 0]) =>
+      _buffer.getFloat64(_offset + delta, Endianness.LITTLE_ENDIAN);
+
   int _getInt32([int delta = 0]) =>
       _buffer.getInt32(_offset + delta, Endianness.LITTLE_ENDIAN);
 
   int _getInt8([int delta = 0]) => _buffer.getInt8(_offset + delta);
 
   int _getUint16([int delta = 0]) =>
       _buffer.getUint16(_offset + delta, Endianness.LITTLE_ENDIAN);
 
   int _getUint32([int delta = 0]) =>
       _buffer.getUint32(_offset + delta, Endianness.LITTLE_ENDIAN);
 
+  int _getUint64([int delta = 0]) =>
+      _buffer.getUint64(_offset + delta, Endianness.LITTLE_ENDIAN);
+
   /**
    * If the [byteList] is already a [Uint8List] return it.
    * Otherwise return a [Uint8List] copy of the [byteList].
    */
   static Uint8List _asUint8List(List<int> byteList) {
     if (byteList is Uint8List) {
       return byteList;
     } else {
       return new Uint8List.fromList(byteList);
     }
@@ skipping 219 matching lines @@
     _setUint32AtTail(_buf, tail, values.length);
     tail -= 4;
     for (Offset value in values) {
       _setUint32AtTail(_buf, tail, tail - value._tail);
       tail -= 4;
     }
     return result;
   }
 
   /**
+   * Write the given list of 64-bit float [values].
+   */
+  Offset writeListFloat64(List<double> values) {
+    if (_currentVTable != null) {
+      throw new StateError(
+          'Cannot write a non-scalar value while writing a table.');
+    }
+    _prepare(8, 1 + values.length);
+    Offset result = new Offset(_tail);
+    int tail = _tail;
+    _setUint64AtTail(_buf, tail, values.length);
+    tail -= 8;
+    for (double value in values) {
+      _setFloat64AtTail(_buf, tail, value);
+      tail -= 8;
+    }
+    return result;
+  }
+
+  /**
    * Write the given list of signed 32-bit integer [values].
    */
   Offset writeListInt32(List<int> values) {
     if (_currentVTable != null) {
       throw new StateError(
           'Cannot write a non-scalar value while writing a table.');
     }
     _prepare(4, 1 + values.length);
     Offset result = new Offset(_tail);
     int tail = _tail;
@@ skipping 64 matching lines @@
     _tail += bufSize;
   }
 
   /**
    * Record the offset of the given [field].
    */
   void _trackField(int field) {
     _currentVTable.addField(field, _tail);
   }
 
+  static void _setFloat64AtTail(ByteData _buf, int tail, double x) {
+    _buf.setFloat64(_buf.lengthInBytes - tail, x, Endianness.LITTLE_ENDIAN);
+  }
+
   static void _setInt32AtTail(ByteData _buf, int tail, int x) {
     _buf.setInt32(_buf.lengthInBytes - tail, x, Endianness.LITTLE_ENDIAN);
   }
 
   static void _setUint32AtTail(ByteData _buf, int tail, int x) {
     _buf.setUint32(_buf.lengthInBytes - tail, x, Endianness.LITTLE_ENDIAN);
   }
+
+  static void _setUint64AtTail(ByteData _buf, int tail, int x) {
+    _buf.setUint64(_buf.lengthInBytes - tail, x, Endianness.LITTLE_ENDIAN);
+  }
 }
 
 /**
+ * The reader of lists of 64-bit float values.
+ *
+ * The returned unmodifiable lists lazily read values on access.
+ */
+class Float64ListReader extends Reader<List<double>> {
+  const Float64ListReader();
+
+  @override
+  int get size => 4;
+
+  @override
+  List<double> read(BufferPointer bp) => new _FbFloat64List(bp.derefObject());
+}
+
+/**
  * The reader of 32-bit signed integers.
  */
 class Int32Reader extends Reader<int> {
   const Int32Reader() : super();
 
   @override
   int get size => 4;
 
   @override
   int read(BufferPointer bp) => bp._getInt32();
@@ skipping 20 matching lines @@
 class ListReader<E> extends Reader<List<E>> {
   final Reader<E> _elementReader;
 
   const ListReader(this._elementReader);
 
   @override
   int get size => 4;
 
   @override
   List<E> read(BufferPointer bp) =>
-      new _FbList<E>(_elementReader, bp.derefObject());
+      new _FbInt32List<E>(_elementReader, bp.derefObject());
 }
 
 /**
  * The offset from the end of the buffer to a serialized object of the type [T].
  */
 class Offset<T> {
   final int _tail;
 
   Offset(this._tail);
 }
@@ skipping 65 matching lines @@
    */
   T createObject(BufferPointer bp);
 
   @override
   T read(BufferPointer bp) {
     bp = bp.derefObject();
     return createObject(bp);
   }
 }
 
-class _FbList<E> extends Object with ListMixin<E> implements List<E> {
+/**
+ * The list backed by 64-bit values - Uint64 length and Float64.
+ */
+class _FbFloat64List extends _FbList<double> {
+  final BufferPointer bp;
+
+  int _length;
+  List<double> _items;
+
+  _FbFloat64List(this.bp);
+
+  @override
+  int get length {
+    _length ??= bp._getUint64();
+    return _length;
+  }
+
+  @override
+  double operator [](int i) {
+    _items ??= new List<double>(length);
+    double item = _items[i];
+    if (item == null) {
+      BufferPointer ref = bp._advance(8 + 8 * i);
+      item = ref._getFloat64();
+      _items[i] = item;
+    }
+    return item;
+  }
+}
+
+/**
+ * The list backed by 32-bit values - offsets or integers.
+ */
+class _FbInt32List<E> extends _FbList<E> {
   final Reader<E> elementReader;
   final BufferPointer bp;
 
   int _length;
   List<E> _items;
 
-  _FbList(this.elementReader, this.bp);
+  _FbInt32List(this.elementReader, this.bp);
 
   @override
   int get length {
     _length ??= bp._getUint32();
     return _length;
   }
 
   @override
-  void set length(int i) =>
-      throw new StateError('Attempt to modify immutable list');
-
-  @override
   E operator [](int i) {
     _items ??= new List<E>(length);
     E item = _items[i];
     if (item == null) {
-      BufferPointer ref = bp._advance(4 + elementReader.size * i);
+      BufferPointer ref = bp._advance(4 + 4 * i);
       item = elementReader.read(ref);
       _items[i] = item;
     }
     return item;
   }
+}
+
+/**
+ * An immutable list abstract list.

[Paul Berry, 2016/01/15 22:26:37]

This comment is hard to interpret.  How about something like "base class for
immutable lists read from flatbuffers"?

+ */
+abstract class _FbList<E> extends Object with ListMixin<E> implements List<E> {
+  @override
+  void set length(int i) =>
+      throw new StateError('Attempt to modify immutable list');
 
   @override
   void operator []=(int i, E e) =>
       throw new StateError('Attempt to modify immutable list');
 }
 
 /**
  * Class that describes the structure of a table.
  */
 class _VTable {
@@ skipping 60 matching lines @@
     // Table size.
     buf.setUint16(bufOffset, tableSize, Endianness.LITTLE_ENDIAN);
     bufOffset += 2;
     // Field offsets.
     for (int fieldOffset in fieldOffsets) {
       buf.setUint16(bufOffset, fieldOffset, Endianness.LITTLE_ENDIAN);
       bufOffset += 2;
     }
   }
 }