Support for boolean lists in FlatBuffer.

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';
 
 /**
+ * Reader of lists of boolean values.
+ *
+ * The returned unmodifiable lists lazily read values on access.
+ */
+class BoolListReader extends Reader<List<bool>> {
+  const BoolListReader();
+
+  @override
+  int get size => 4;
+
+  @override
+  List<bool> read(BufferPointer bp) => new _FbBoolList(bp.derefObject());
+}
+
+/**
  * The reader of booleans.
  */
 class BoolReader extends Reader<bool> {
   const BoolReader() : super();
 
   @override
   int get size => 1;
 
   @override
   bool read(BufferPointer bp) => bp._getInt8() != 0;
@@ skipping 305 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 boolean [values].
+   */
+  Offset writeListBool(List<bool> values) {
+    int bitLength = values.length;
+    bool hasPartial = bitLength % 32 != 0;
+    int intLength = 1 + bitLength ~/ 32 + (hasPartial ? 1 : 0);
+    // Prepare the backing Uint32 list.
+    List<int> intItems = new List<int>(intLength);
+    // Put the bit length as the 0-th item.
+    intItems[0] = bitLength;
+    // Record every bit.
+    int itemIndex = 1;
+    int item = 0;
+    int mask = 1;
+    for (int bitIndex = 0; bitIndex < bitLength; bitIndex++) {
+      if (bitIndex != 0 && (bitIndex % 32 == 0)) {
+        intItems[itemIndex++] = item;
+        item = 0;
+        mask = 1;
+      }
+      if (values[bitIndex]) {
+        item |= mask;
+      }
+      mask <<= 1;
+    }
+    if (hasPartial) {

[Paul Berry, 2016/02/29 21:12:32]

Change this to `if (values.isNotEmpty)`.  Otherwise when `values.length` is a
nonzero multiple of 32, we won't store the last int.

+      intItems[itemIndex] = item;
+    }
+    // Write as a Uint32 list.
+    return writeListUint32(intItems);
+  }
+
+  /**
    * Write the given list of 64-bit float [values].
    */
   Offset writeListFloat64(List<double> values) {
     _ensureNoVTable();
     _prepare(8, 1 + values.length);
     Offset result = new Offset(_tail);
     int tail = _tail;
     _setUint32AtTail(_buf, tail, values.length);
     tail -= 8;
     for (double value in values) {
@@ skipping 290 matching lines @@
   T createObject(BufferPointer bp);
 
   @override
   T read(BufferPointer bp) {
     bp = bp.derefObject();
     return createObject(bp);
   }
 }
 
 /**
- * Reader of lists of 32-bit float values.
+ * Reader of lists of unsigned 32-bit integer values.
  *
  * The returned unmodifiable lists lazily read values on access.
  */
 class Uint32ListReader extends Reader<List<int>> {
   const Uint32ListReader();
 
   @override
   int get size => 4;
 
   @override
@@ skipping 20 matching lines @@
   const Uint8Reader() : super();
 
   @override
   int get size => 1;
 
   @override
   int read(BufferPointer bp) => bp._getUint8();
 }
 
 /**
+ * List of booleans backed by 32-bit unsigned integers.
+ */
+class _FbBoolList extends Object with ListMixin<bool> implements List<bool> {
+  final _FbUint32List uint32List;
+
+  _FbBoolList(BufferPointer bp) : uint32List = new _FbUint32List(bp);
+
+  @override
+  int get length => uint32List[0];
+
+  @override
+  void set length(int i) =>
+      throw new StateError('Attempt to modify immutable list');
+
+  @override
+  bool operator [](int i) {
+    int index = i ~/ 32;
+    int mask = 1 << i % 32;
+    return uint32List[1 + index] & mask != 0;
+  }
+
+  @override
+  void operator []=(int i, bool e) =>
+      throw new StateError('Attempt to modify immutable list');
+}
+
+/**
  * The list backed by 64-bit values - Uint64 length and Float64.
  */
 class _FbFloat64List extends _FbList<double> {
   List<double> _items;
 
   _FbFloat64List(BufferPointer bp) : super(bp);
 
   @override
   double operator [](int i) {
     _items ??= new List<double>(length);
@@ skipping 141 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;
     }
   }
 }