Add support for Uint32 fields and lists in Flat Buffers.

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 160 matching lines @@
       throw new StateError('Start a table before adding values.');
     }
     if (offset != null) {
       _prepare(4, 1);
       _trackField(field);
       _setUint32AtTail(_buf, _tail, _tail - offset._tail);
     }
   }
 
   /**
+   * Add the [field] with the given 32-bit unsigned integer [value].  The field
+   * is not added if the [value] is equal to [def].
+   */
+  void addUint32(int field, int value, [int def]) {
+    if (_currentVTable == null) {
+      throw new StateError('Start a table before adding values.');
+    }
+    if (value != null && value != def) {
+      int size = 4;
+      _prepare(size, 1);
+      _trackField(field);
+      _setUint32AtTail(_buf, _tail, value);
+    }
+  }
+
+  /**
    * End the current table and return its offset.
    */
   Offset endTable() {
     if (_currentVTable == null) {
       throw new StateError('Start a table before ending it.');
     }
     // Prepare the size of the current table.
     _currentVTable.tableSize = _tail - _currentTableEndTail;
     // Prepare for writing the VTable.
     _prepare(4, 1);
@@ skipping 144 matching lines @@
     _setUint32AtTail(_buf, tail, values.length);
     tail -= 4;
     for (int value in values) {
       _setInt32AtTail(_buf, tail, value);
       tail -= 4;
     }
     return result;
   }
 
   /**
+   * Write the given list of unsigned 32-bit integer [values].
+   */
+  Offset writeListUint32(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;
+    _setUint32AtTail(_buf, tail, values.length);
+    tail -= 4;
+    for (int value in values) {
+      _setUint32AtTail(_buf, tail, value);
+      tail -= 4;
+    }
+    return result;
+  }
+
+  /**
    * Write the given string [value] and return its [Offset], or `null` if
    * the [value] is equal to [def].
    */
   Offset<String> writeString(String value, [String def]) {
     if (_currentVTable != null) {
       throw new StateError(
           'Cannot write a non-scalar value while writing a table.');
     }
     if (value != def) {
       // TODO(scheglov) optimize for ASCII strings
@@ skipping 73 matching lines @@
   const Float64ListReader();
 
   @override
   int get size => 4;
 
   @override
   List<double> read(BufferPointer bp) => new _FbFloat64List(bp.derefObject());
 }
 
 /**
- * The reader of 32-bit signed integers.
+ * The reader of signed 32-bit integers.
  */
 class Int32Reader extends Reader<int> {
   const Int32Reader() : super();
 
   @override
   int get size => 4;
 
   @override
   int read(BufferPointer bp) => bp._getInt32();
 }
@@ skipping 106 matching lines @@
   T createObject(BufferPointer bp);
 
   @override
   T read(BufferPointer bp) {
     bp = bp.derefObject();
     return createObject(bp);
   }
 }
 
 /**
+ * The reader of unsigned 32-bit integers.
+ */
+class Uint32Reader extends Reader<int> {
+  const Uint32Reader() : super();
+
+  @override
+  int get size => 4;
+
+  @override
+  int read(BufferPointer bp) => bp._getUint32();
+}
+
+/**
  * 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);
 
@@ skipping 127 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;
     }
   }
 }