assert(_inVTable);
// Prepare for writing the VTable.
_prepare(_sizeofInt32, 1);
- int tableTail = _tail;
+ var tableTail = _tail;
// Prepare the size of the current table.
final currentVTable = _currentVTable!;
currentVTable.tableSize = tableTail - _currentTableEndTail;
// Try to find an existing compatible VTable.
if (deduplicateTables) {
// Search backward - more likely to have recently used one
- for (int i = _vTables.length - 1; i >= 0; i--) {
- final int vt2Offset = _vTables[i];
- final int vt2Start = _buf.lengthInBytes - vt2Offset;
- final int vt2Size = _buf.getUint16(vt2Start, Endian.little);
+ for (var i = _vTables.length - 1; i >= 0; i--) {
+ final vt2Offset = _vTables[i];
+ final vt2Start = _buf.lengthInBytes - vt2Offset;
+ final vt2Size = _buf.getUint16(vt2Start, Endian.little);
if (currentVTable._vTableSize == vt2Size &&
currentVTable._offsetsMatch(vt2Start, _buf)) {
final finishedSize = size();
_setUint32AtTail(finishedSize, finishedSize - offset);
if (fileIdentifier != null) {
- for (int i = 0; i < 4; i++) {
+ for (var i = 0; i < 4; i++) {
_setUint8AtTail(
finishedSize - _sizeofUint32 - i, fileIdentifier.codeUnitAt(i));
}
/// Writes a list of Structs to the buffer, returning the offset
int writeListOfStructs(List<ObjectBuilder> structBuilders) {
assert(!_inVTable);
- for (int i = structBuilders.length - 1; i >= 0; i--) {
+ for (var i = structBuilders.length - 1; i >= 0; i--) {
structBuilders[i].finish(this);
}
return endStructVector(structBuilders.length);
int writeList(List<int> values) {
assert(!_inVTable);
_prepare(_sizeofUint32, 1 + values.length);
- final int result = _tail;
- int tail = _tail;
+ final result = _tail;
+ var tail = _tail;
_setUint32AtTail(tail, values.length);
tail -= _sizeofUint32;
- for (int value in values) {
+ for (var value in values) {
_setUint32AtTail(tail, tail - value);
tail -= _sizeofUint32;
}
int writeListFloat64(List<double> values) {
assert(!_inVTable);
_prepare(_sizeofFloat64, values.length, additionalBytes: _sizeofUint32);
- final int result = _tail;
- int tail = _tail;
+ final result = _tail;
+ var tail = _tail;
_setUint32AtTail(tail, values.length);
tail -= _sizeofUint32;
- for (double value in values) {
+ for (var value in values) {
_setFloat64AtTail(tail, value);
tail -= _sizeofFloat64;
}
int writeListFloat32(List<double> values) {
assert(!_inVTable);
_prepare(_sizeofFloat32, 1 + values.length);
- final int result = _tail;
- int tail = _tail;
+ final result = _tail;
+ var tail = _tail;
_setUint32AtTail(tail, values.length);
tail -= _sizeofUint32;
- for (double value in values) {
+ for (var value in values) {
_setFloat32AtTail(tail, value);
tail -= _sizeofFloat32;
}
int writeListInt64(List<int> values) {
assert(!_inVTable);
_prepare(_sizeofInt64, values.length, additionalBytes: _sizeofUint32);
- final int result = _tail;
- int tail = _tail;
+ final result = _tail;
+ var tail = _tail;
_setUint32AtTail(tail, values.length);
tail -= _sizeofUint32;
- for (int value in values) {
+ for (var value in values) {
_setInt64AtTail(tail, value);
tail -= _sizeofInt64;
}
int writeListUint64(List<int> values) {
assert(!_inVTable);
_prepare(_sizeofUint64, values.length, additionalBytes: _sizeofUint32);
- final int result = _tail;
- int tail = _tail;
+ final result = _tail;
+ var tail = _tail;
_setUint32AtTail(tail, values.length);
tail -= _sizeofUint32;
- for (int value in values) {
+ for (var value in values) {
_setUint64AtTail(tail, value);
tail -= _sizeofUint64;
}
int writeListInt32(List<int> values) {
assert(!_inVTable);
_prepare(_sizeofUint32, 1 + values.length);
- final int result = _tail;
- int tail = _tail;
+ final result = _tail;
+ var tail = _tail;
_setUint32AtTail(tail, values.length);
tail -= _sizeofUint32;
- for (int value in values) {
+ for (var value in values) {
_setInt32AtTail(tail, value);
tail -= _sizeofInt32;
}
int writeListUint32(List<int> values) {
assert(!_inVTable);
_prepare(_sizeofUint32, 1 + values.length);
- final int result = _tail;
- int tail = _tail;
+ final result = _tail;
+ var tail = _tail;
_setUint32AtTail(tail, values.length);
tail -= _sizeofUint32;
- for (int value in values) {
+ for (var value in values) {
_setUint32AtTail(tail, value);
tail -= _sizeofUint32;
}
int writeListInt16(List<int> values) {
assert(!_inVTable);
_prepare(_sizeofUint32, 1, additionalBytes: 2 * values.length);
- final int result = _tail;
- int tail = _tail;
+ final result = _tail;
+ var tail = _tail;
_setUint32AtTail(tail, values.length);
tail -= _sizeofUint32;
- for (int value in values) {
+ for (var value in values) {
_setInt16AtTail(tail, value);
tail -= _sizeofInt16;
}
int writeListUint16(List<int> values) {
assert(!_inVTable);
_prepare(_sizeofUint32, 1, additionalBytes: 2 * values.length);
- final int result = _tail;
- int tail = _tail;
+ final result = _tail;
+ var tail = _tail;
_setUint32AtTail(tail, values.length);
tail -= _sizeofUint32;
- for (int value in values) {
+ for (var value in values) {
_setUint16AtTail(tail, value);
tail -= _sizeofUint16;
}
int writeListInt8(List<int> values) {
assert(!_inVTable);
_prepare(_sizeofUint32, 1, additionalBytes: values.length);
- final int result = _tail;
- int tail = _tail;
+ final result = _tail;
+ var tail = _tail;
_setUint32AtTail(tail, values.length);
tail -= _sizeofUint32;
- for (int value in values) {
+ for (var value in values) {
_setInt8AtTail(tail, value);
tail -= _sizeofUint8;
}
int writeListUint8(List<int> values) {
assert(!_inVTable);
_prepare(_sizeofUint32, 1, additionalBytes: values.length);
- final int result = _tail;
- int tail = _tail;
+ final result = _tail;
+ var tail = _tail;
_setUint32AtTail(tail, values.length);
tail -= _sizeofUint32;
- for (int value in values) {
+ for (var value in values) {
_setUint8AtTail(tail, value);
tail -= _sizeofUint8;
}
_prepare(4, 1, additionalBytes: length + 1);
_setUint32AtTail(_tail, length);
var offset = _buf.lengthInBytes - _tail + 4;
- for (int i = 0; i < length; i++) {
+ for (var i = 0; i < length; i++) {
_buf.setUint8(offset++, bytes[i]);
}
_buf.setUint8(offset, 0); // trailing zero
/// Zero-pads the buffer, which may be required for some struct layouts.
@pragma('vm:prefer-inline')
void pad(int howManyBytes) {
- for (int i = 0; i < howManyBytes; i++) {
+ for (var i = 0; i < howManyBytes; i++) {
putUint8(0);
}
}
_maxAlign = size;
}
// Prepare amount of required space.
- int dataSize = size * count + additionalBytes;
- int alignDelta = (-(_tail + dataSize)) & (size - 1);
- int bufSize = alignDelta + dataSize;
+ var dataSize = size * count + additionalBytes;
+ var alignDelta = (-(_tail + dataSize)) & (size - 1);
+ var bufSize = alignDelta + dataSize;
// Ensure that we have the required amount of space.
{
- int oldCapacity = _buf.lengthInBytes;
+ var oldCapacity = _buf.lengthInBytes;
if (_tail + bufSize > oldCapacity) {
- int desiredNewCapacity = (oldCapacity + bufSize) * 2;
- int deltaCapacity = desiredNewCapacity - oldCapacity;
+ var desiredNewCapacity = (oldCapacity + bufSize) * 2;
+ var deltaCapacity = desiredNewCapacity - oldCapacity;
deltaCapacity += (-deltaCapacity) & (_maxAlign - 1);
- int newCapacity = oldCapacity + deltaCapacity;
+ var newCapacity = oldCapacity + deltaCapacity;
_buf = _allocator.resize(_buf, newCapacity, _tail, 0);
}
}
/// Read the value of the given [field] in the given [object].
@pragma('vm:prefer-inline')
T vTableGet(BufferContext object, int offset, int field, T defaultValue) {
- int fieldOffset = _vTableFieldOffset(object, offset, field);
+ var fieldOffset = _vTableFieldOffset(object, offset, field);
return fieldOffset == 0 ? defaultValue : read(object, offset + fieldOffset);
}
/// Read the value of the given [field] in the given [object].
@pragma('vm:prefer-inline')
T? vTableGetNullable(BufferContext object, int offset, int field) {
- int fieldOffset = _vTableFieldOffset(object, offset, field);
+ var fieldOffset = _vTableFieldOffset(object, offset, field);
return fieldOffset == 0 ? null : read(object, offset + fieldOffset);
}
@pragma('vm:prefer-inline')
int _vTableFieldOffset(BufferContext object, int offset, int field) {
- int vTableSOffset = object._getInt32(offset);
+ var vTableSOffset = object._getInt32(offset);
int vTableOffset = offset - vTableSOffset;
int vTableSize = object._getUint16(vTableOffset);
if (field >= vTableSize) return 0;
@pragma('vm:prefer-inline')
E operator [](int i) {
_items ??= List<E?>.filled(length, null);
- E? item = _items![i];
+ var item = _items![i];
if (item == null) {
item = elementReader.read(bc, offset + 4 + elementReader.size * i);
_items![i] = item;
@pragma('vm:prefer-inline')
bool _offsetsMatch(int vt2Start, ByteData buf) {
assert(offsetsComputed);
- for (int i = 0; i < numFields; i++) {
+ for (var i = 0; i < numFields; i++) {
if (fieldOffsets[i] !=
buf.getUint16(vt2Start + _metadataLength + (2 * i), Endian.little)) {
return false;
buf.setUint16(bufOffset, tableSize, Endian.little);
bufOffset += 2;
// Field offsets.
- for (int i = 0; i < numFields; i++) {
+ for (var i = 0; i < numFields; i++) {
buf.setUint16(bufOffset, fieldOffsets[i], Endian.little);
bufOffset += 2;
}
projects / platform / upstream / flatbuffers.git / commitdiff