~ConcurrentList () {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
_head = null;
HazardPointer.set_pointer<Node<G>?> (&_tail, null);
}
public override int size {
get {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
int result = 0;
for (var iter = iterator (); iter.next ();)
result++;
*/
public override bool contains (G item) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
for (var iter = iterator (); iter.next ();)
if (equal_func (item, iter.get ()))
return true;
*/
public override bool add (G item) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
Node<G> node = new Node<G> (item);
node.insert (get_tail (), null);
return true;
*/
public override bool remove (G item) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
Gee.Iterator<G> iter = iterator ();
while (iter.next ()) {
if (equal_func (item, iter.get ())) {
*/
public override void clear () {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
var iter = iterator ();
while (iter.next ())
iter.remove ();
*/
public override G? get (int index) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
assert (index >= 0);
for (var iterator = iterator (); iterator.next ();)
if (index-- == 0)
*/
public override void set (int index, G item) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
assert (index >= 0);
for (var iterator = list_iterator (); iterator.next ();) {
if (index-- == 0) {
*/
public override int index_of (G item) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
int index = 0;
for (var iterator = list_iterator (); iterator.next (); index++)
if (equal_func (item, iterator.get ()))
*/
public override void insert (int index, G item) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
assert (index >= 0);
if (index == 0) {
var prev = _head;
*/
public override G remove_at (int index) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
for (var iterator = list_iterator (); iterator.next ();) {
if (index-- == 0) {
G data = iterator.get ();
*/
public override List<G>? slice (int start, int end) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
assert (0 <= start);
assert (start <= end);
var list = new ConcurrentList<G>.with_closure (_equal_func);
public bool next () {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
Node<G>? _old_prev = _removed ? _prev : null;
bool success = Node.proceed<G> (ref _prev, ref _curr);
if (success) {
public bool has_next () {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
Node<G>? prev = _prev;
Node<G> curr = _curr;
return Node.proceed<G> (ref prev, ref curr);
public new G get () {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
assert (valid);
return HazardPointer.get_pointer<G> (&_curr._data);
}
public new void set (G item) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
assert (valid);
#if DEBUG
G item_copy = item;
public void remove () {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
assert (valid);
_curr.remove (_prev);
_removed = true;
public void add (G item) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
assert (valid);
if (!Node.proceed<G> (ref _prev, ref _curr)) {
_prev = (owned)_curr;
public new bool foreach (ForallFunc<G> f) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
if (_prev != null && !_removed) {
if (!f (HazardPointer.get_pointer<G> (&_curr._data))) {
return false;
~ConcurrentSet () {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
_head = null;
}
public override bool contains (G key) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
Tower<G> prev = _head;
return Tower.search<G> (_cmp, key, ref prev, null);
}
public override bool add (G key) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
Rand *rnd = rand.get ();
if (rnd == null) {
rand.set (rnd = new Rand ());
public override bool remove (G item) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
TowerIter<G> prev = TowerIter<G>();
for (int i = 0; i < _MAX_HEIGHT; i++) {
prev._iter[i] = _head;
public override void clear () {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
Tower<G>? first;
while ((first = _head.get_next (0)) != null) {
remove (first._data);
public override G first () {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
Tower<G>? prev = null;
Tower<G> curr = _head;
if (Tower.proceed<G> (_cmp, ref prev, ref curr, 0)) {
public override G last () {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
Tower<G>? prev = null;
Tower<G> curr = _head;
bool found = false;
public override Gee.Iterator<G>? iterator_at (G element) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
TowerIter<G> prev = TowerIter<G> ();
TowerIter<G> curr;
for (int i = 0; i < _MAX_HEIGHT; i++) {
public override G? lower (G element) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
Tower<G> prev = _head;
Tower.search<G> (_cmp, element, ref prev);
if (prev == _head) {
public override G? higher (G element) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
Tower<G> prev = _head;
Tower<G>? next;
if (Tower.search<G> (_cmp, element, ref prev, out next)) {
public override G? floor (G element) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
Tower<G> prev = _head;
Tower<G>? next;
if (Tower.search<G> (_cmp, element, ref prev, out next)) {
public override G? ceil (G element) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
Tower<G> prev = _head;
Tower<G>? next;
Tower.search<G> (_cmp, element, ref prev, out next);
public override SortedSet<G> head_set (G before) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
return new SubSet<G> (new Range<G>.head (this, before));
}
public override SortedSet<G> tail_set (G after) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
return new SubSet<G> (new Range<G>.tail (this, after));
}
public override SortedSet<G> sub_set (G from, G to) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
return new SubSet<G> (new Range<G> (this, from, to));
}
public new bool foreach (ForallFunc<G> f) {
assert (_curr != null);
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
if (_prev._iter[0] != null && !_removed) {
if (!f (_curr._data)) {
assert (_curr != null);
public bool next () {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
Tower<G>? new_prev = _prev._iter[0];
Tower<G>? new_curr = _curr;
bool success = Tower.proceed<G> (_set._cmp, ref new_prev, ref new_curr, 0);
public bool has_next () {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
Tower<G> prev = _prev._iter[0];
Tower<G>? curr = _curr;
return Tower.proceed<G> (_set._cmp, ref prev, ref curr, 0);
public void remove () {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
assert (valid);
if (Tower.remove<G> (_set._cmp, ref _prev, _curr)) {
AtomicInt.dec_and_test (ref _set._size);
public override int size {
get {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
Tower<G>? curr;
Range.improve_bookmark<G> (_range, out curr);
if (curr != null) {
public bool is_empty {
get {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
Tower<G>? curr;
Range.improve_bookmark<G> (_range, out curr);
return curr != null;
public override Gee.Iterator<G> iterator () {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
return new SubIterator<G> (_range);
}
public override bool contains (G item) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
if (!Range.inside<G> (_range, item)) {
return false;
}
public override bool add (G key) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
if (!Range.inside<G> (_range, key)) {
return false;
}
public override bool remove (G key) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
if (!Range.inside<G> (_range, key)) {
return false;
}
public override void clear () {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
TowerIter<G> prev;
Tower<G>? first;
Range.improve_bookmark<G> (_range, out first, out prev);
public override G? first () {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
Tower<G>? first;
Range.improve_bookmark<G> (_range, out first);
if (first == null) {
public override G? last () {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
TowerIter<G> prev;
Range.improve_bookmark<G> (_range, null, out prev);
Tower<G>? curr = null;
public override Gee.Iterator<G>? iterator_at (G element) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
if (!Range.inside<G> (_range, element)) {
return null;
}
public override G? lower (G element) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
switch (Range.cmp<G> (_range, element)) {
case Range.Position.BEFORE:
case Range.Position.EMPTY:
public override G? higher (G element) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
switch (Range.cmp<G> (_range, element)) {
case Range.Position.BEFORE:
return first ();
public override G? floor (G element) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
switch (Range.cmp<G> (_range, element)) {
case Range.Position.BEFORE:
case Range.Position.EMPTY:
public override G? ceil (G element) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
switch (Range.cmp<G> (_range, element)) {
case Range.Position.BEFORE:
return first ();
public override SortedSet<G> head_set (G before) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
return new SubSet<G> (Range.cut_tail (_range, before));
}
public override SortedSet<G> tail_set (G after) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
return new SubSet<G> (Range.cut_head (_range, after));
}
public override SortedSet<G> sub_set (G from, G to) {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
return new SubSet<G> (Range.cut (_range, from, to));
}
public new bool foreach (ForallFunc<G> f) {
assert (_curr != null);
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
if (!begin ()) {
return true;
}
public bool next () {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
if (_prev._iter[0] == null) {
return begin ();
} else {
public bool has_next () {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
if (_prev._iter[0] == null) {
Tower<G> next;
Range.improve_bookmark<G> (_range, out next);
public void remove () {
HazardPointer.Context ctx = new HazardPointer.Context ();
+ Utils.Misc.unused (ctx);
assert (valid);
if (Tower.remove<G> (_range._set._cmp, ref _prev, _curr)) {
AtomicInt.dec_and_test (ref _range._set._size);