#197

Build # #197

Build Type

push

Committed by

Commit Message

<a href="https://github.com/denniskaselow/dartemis/commit/<a class=hub.com/denniskaselow/dartemis/commit/d2c86add299c2681951ca1f0b140d416e71bad09">d2c86add2<a href="https://github.com/denniskaselow/dartemis/commit/d2c86add299c2681951ca1f0b140d416e71bad09">&quot;&gt;Revert &amp;quot;fix crash when getting component outside of bag allocation (#68)&amp;quot; (#69)

This reverts commit </a><a class="double-link" href="https://github.com/denniskaselow/dartemis/commit/<a class="double-link" href="https://github.com/denniskaselow/dartemis/commit/a6d1d6e153224e8afd16bcdcaddce0347469c3cb">a6d1d6e15</a>">a6d1d6e15</a><a href="https://github.com/denniskaselow/dartemis/commit/d2c86add299c2681951ca1f0b140d416e71bad09">.

Run Details

7 of 7 new or added lines in 1 file covered. (100.0%)

486 of 668 relevant lines covered (72.75%)

1.43 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

75.44

/lib/src/core/utils/bag.dart

part of '../../../dartemis.dart';

/// Collection type a bit like List but does not preserve the order of its
/// entities, speedwise it is very good, especially suited for games.
// ignore: prefer_mixin
class Bag<E> with IterableMixin<E> {
  List<E?> _data;
  int _size = 0;

  /// Create a [Bag] with an initial capacity of [capacity].
  Bag({int capacity = 32}) : _data = List<E?>.filled(capacity, null);

  /// Creates a new [Bag] with the elements of [iterable].
  Bag.from(Iterable<E> iterable)
      : _data = iterable.toList(growable: false),
        _size = iterable.length;

  /// Returns the element at the specified [index] in the bag.
  E? operator [](int index) => _data[index];

  /// Returns the number of elements in this bag.
  int get size => _size;

  /// Returns [:true:] if this bag contains no elements.
  @override
  bool get isEmpty => size == 0;

  /// Removes the element at the specified [index] in this bag. Does this by
  /// overwriting with the last element and then removing the last element.
  E? removeAt(int index) {
    // make copy of element to remove so it can be returned
    final o = _data[index];
    // overwrite item to remove with last element
    _data[index] = _data[--_size];
    // null last element, so gc can do its work
    _data[size] = null;

    return o;
  }

  /// Remove and return the last object in the bag.
  E? removeLast() {
    if (_size > 0) {
      final current = _data[--_size];
      _data[size] = null;
      return current;
    }
    return null;
  }

  /// Removes the first occurrence of the specified element from this bag, if
  /// it is present. If the Bag does not contain the element, it is unchanged.
  /// Does this by overwriting with the last element and then removing the last
  /// element.
  /// Returns [:true:] if this list contained the specified [element].
  bool remove(E element) {
    for (var i = 0; i < size; i++) {
      final current = _data[i];

      if (element == current) {
        // overwrite item to remove with last element
        _data[i] = _data[--_size];
        // null last element, so gc can do its work
        _data[size] = null;
        return true;
      }
    }

    return false;
  }

  /// Returns the number of elements the bag can hold without growing.
  int get capacity => _data.length;

  /// Adds the specified [element] to the end of this bag. If needed also
  /// increases the capacity of the bag.
  void add(E element) {
    // is size greater than capacity increase capacity
    if (_size == _data.length) {
      _grow();
    }
    _data[_size++] = element;
  }

  /// Sets [element] at specified [index] in the bag.
  void operator []=(int index, E element) {
    if (index >= _data.length) {
      _growTo(index * 2);
    }
    if (_size <= index) {
      _size = index + 1;
    }
    _data[index] = element;
  }

  void _grow() => _growTo(_calculateNewCapacity(_data.length));

  int _calculateNewCapacity(int requiredLength) =>
      (requiredLength * 3) ~/ 2 + 1;

  void _growTo(int newCapacity) {
    final oldData = _data;
    _data = List<E?>.filled(newCapacity, null)
      ..setRange(0, oldData.length, oldData);
  }

  void _ensureCapacity(int index) {
    if (index >= _data.length) {
      _growTo(index * 2);
    }
  }

  /// Removes all of the elements from this bag. The bag will be empty after
  /// this call returns.
  void clear() {
    // null all elements so gc can clean up
    for (var i = 0; i < _size; i++) {
      _data[i] = null;
    }
    _size = 0;
  }

  /// Add all [items] into this bag.
  void addAll(Bag<E> items) => items.forEach(add);

  /// Returns [:true:] iff the [index] is within the capacity of the underlying
  /// list.
  bool isIndexWithinBounds(int index) => index < capacity;

  @override
  Iterator<E> get iterator => _data.sublist(0, size).cast<E>().iterator;

  @override
  int get length => size;

  @override
  Bag<R> cast<R>() => Bag<R>(capacity: _data.length)
    .._size = _size
    .._data = _data.cast<R>();
}

1	part of '../../../dartemis.dart';
2
3	/// Collection type a bit like List but does not preserve the order of its
4	/// entities, speedwise it is very good, especially suited for games.
5	// ignore: prefer_mixin
6	class Bag<E> with IterableMixin<E> {
7	List<E?> _data;
8	int _size = 0;
9
10	/// Create a [Bag] with an initial capacity of [capacity].
11	Bag({int capacity = 32}) : _data = List<E?>.filled(capacity, null);	2✔
12
13	/// Creates a new [Bag] with the elements of [iterable].
14	Bag.from(Iterable<E> iterable)	×
15	: _data = iterable.toList(growable: false),	×
16	_size = iterable.length;	×
17
18	/// Returns the element at the specified [index] in the bag.
19	E? operator [](int index) => _data[index];	3✔
20
21	/// Returns the number of elements in this bag.
22	int get size => _size;	2✔
23
24	/// Returns [:true:] if this bag contains no elements.
25	@override	×
26	bool get isEmpty => size == 0;	×
27
28	/// Removes the element at the specified [index] in this bag. Does this by
29	/// overwriting with the last element and then removing the last element.
30	E? removeAt(int index) {	1✔
31	// make copy of element to remove so it can be returned
32	final o = _data[index];	2✔
33	// overwrite item to remove with last element
34	_data[index] = _data[--_size];	6✔
35	// null last element, so gc can do its work
36	_data[size] = null;	3✔
37
38	return o;
39	}
40
41	/// Remove and return the last object in the bag.
42	E? removeLast() {	1✔
43	if (_size > 0) {	2✔
44	final current = _data[--_size];	4✔
45	_data[size] = null;	3✔
46	return current;
47	}
48	return null;
49	}
50
51	/// Removes the first occurrence of the specified element from this bag, if
52	/// it is present. If the Bag does not contain the element, it is unchanged.
53	/// Does this by overwriting with the last element and then removing the last
54	/// element.
55	/// Returns [:true:] if this list contained the specified [element].
56	bool remove(E element) {	1✔
57	for (var i = 0; i < size; i++) {	3✔
58	final current = _data[i];	2✔
59
60	if (element == current) {	1✔
61	// overwrite item to remove with last element
62	_data[i] = _data[--_size];	6✔
63	// null last element, so gc can do its work
64	_data[size] = null;	3✔
65	return true;
66	}
67	}
68
69	return false;
70	}
71
72	/// Returns the number of elements the bag can hold without growing.
73	int get capacity => _data.length;	×
74
75	/// Adds the specified [element] to the end of this bag. If needed also
76	/// increases the capacity of the bag.
77	void add(E element) {	1✔
78	// is size greater than capacity increase capacity
79	if (_size == _data.length) {	4✔
80	_grow();	1✔
81	}
82	_data[_size++] = element;	4✔
83	}
84
85	/// Sets [element] at specified [index] in the bag.
86	void operator []=(int index, E element) {	1✔
87	if (index >= _data.length) {	3✔
88	_growTo(index * 2);	2✔
89	}
90	if (_size <= index) {	2✔
91	_size = index + 1;	2✔
92	}
93	_data[index] = element;	2✔
94	}
95
96	void _grow() => _growTo(_calculateNewCapacity(_data.length));	5✔
97
98	int _calculateNewCapacity(int requiredLength) =>	1✔
99	(requiredLength * 3) ~/ 2 + 1;	3✔
100
101	void _growTo(int newCapacity) {	1✔
102	final oldData = _data;	1✔
103	_data = List<E?>.filled(newCapacity, null)	2✔
104	..setRange(0, oldData.length, oldData);	2✔
105	}
106
107	void _ensureCapacity(int index) {	1✔
108	if (index >= _data.length) {	3✔
109	_growTo(index * 2);	2✔
110	}
111	}
112
113	/// Removes all of the elements from this bag. The bag will be empty after
114	/// this call returns.
115	void clear() {	1✔
116	// null all elements so gc can clean up
117	for (var i = 0; i < _size; i++) {	3✔
118	_data[i] = null;	2✔
119	}
120	_size = 0;	1✔
121	}
122
123	/// Add all [items] into this bag.
124	void addAll(Bag<E> items) => items.forEach(add);	×
125
126	/// Returns [:true:] iff the [index] is within the capacity of the underlying
127	/// list.
128	bool isIndexWithinBounds(int index) => index < capacity;	×
129
130	@override	1✔
131	Iterator<E> get iterator => _data.sublist(0, size).cast<E>().iterator;	5✔
132
133	@override	×
134	int get length => size;	×
135
136	@override	×
137	Bag<R> cast<R>() => Bag<R>(capacity: _data.length)	×
138	.._size = _size	×
139	.._data = _data.cast<R>();	×
140	}

denniskaselow / dartemis / #197

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous