changed |= remove (val);
return true;
});
- return changed;
}
/**
public static void improve_bookmark<G> (Range<G> range, out Tower<G>? out_curr = null, out TowerIter<G> prev = null) {
prev = TowerIter<G>();
+ out_curr = null;
switch (range._type) {
case RangeType.HEAD:
if (&out_curr != null) {
public static inline bool search_from_bookmark<G> (CompareDataFunc<G>? cmp, G key, ref TowerIter<G> prev, out TowerIter<G> next = null, uint8 to_level = 0, uint8 from_level = (uint8)_MAX_HEIGHT - 1) {
assert (from_level >= to_level);
+ next = TowerIter<G>();
bool res = false;
for (int i = from_level; i >= to_level; i--) {
unowned Tower<G> tmp_prev = prev._iter[i]; // Should be treated as NULL-like value
public override bool contains (K key) {
return _map.has_key (key);
}
-
- public bool add_all (Collection<K> collection) {
- assert_not_reached ();
- }
-
- public bool remove_all (Collection<K> collection) {
- assert_not_reached ();
- }
-
- public bool retain_all (Collection<K> collection) {
- assert_not_reached ();
- }
-
}
private class ValueCollection<K,V> : AbstractCollection<V> {
}
return false;
}
-
- public bool add_all (Collection<V> collection) {
- assert_not_reached ();
- }
-
- public bool remove_all (Collection<V> collection) {
- assert_not_reached ();
- }
-
- public bool retain_all (Collection<V> collection) {
- assert_not_reached ();
- }
}
private class EntrySet<K,V> : AbstractSet<Map.Entry<K, V>> {
public override bool contains (Map.Entry<K, V> entry) {
return _map.has (entry.key, entry.value);
}
-
- public bool add_all (Collection<Map.Entry<K, V>> entries) {
- assert_not_reached ();
- }
-
- public bool remove_all (Collection<Map.Entry<K, V>> entries) {
- assert_not_reached ();
- }
-
- public bool retain_all (Collection<Map.Entry<K, V>> entries) {
- assert_not_reached ();
- }
}
private abstract class NodeIterator<K,V> : Object {
bool res = _eval.wait_until (_mutex, end_time);
_mutex.unlock ();
if (!res) {
+ value = null;
return false;
}
} else {
public bool wait_until (int64 end_time, out unowned G? value = null) throws Gee.FutureError {
unowned A arg;
bool result;
+ value = null;
if ((result = _base.wait_until (end_time, out arg))) {
value = _func (arg);
}
_mutex.unlock ();
switch (state) {
case State.INIT:
+ value = null;
return false;
case State.ABANDON:
throw new FutureError.ABANDON_PROMISE ("Promise has been abandon");
/**
* {@inheritDoc}
*/
- public BidirSortedMap<K,V> read_only_view {
+ public new BidirSortedMap<K,V> read_only_view {
owned get {
return this;
}
/**
* {@inheritDoc}
*/
- public SortedMap<K, V> read_only_view {
+ public new SortedMap<K, V> read_only_view {
owned get {
return this;
}
switch (state) {
case Stream.YIELD:
if (current == null || !current.next ()) {
+ val = null;
return Stream.CONTINUE;
} else {
val = new Lazy<A> (() => {return current.get ();});
val = new Lazy<A> (() => {return current.get ();});
return Stream.YIELD;
} else {
+ val = null;
return Stream.WAIT;
}
case Stream.WAIT:
val = new Lazy<A> (() => {return current.get ();});
return Stream.YIELD;
} else {
+ val = null;
return Stream.CONTINUE;
}
case Stream.END:
+ val = null;
return Stream.END;
default:
assert_not_reached ();
}
}
- private void fix_removal (ref Node<K,V> node, out K? key = null, out V? value) {
+ private void fix_removal (ref Node<K,V> node, out K? key = null, out V? value = null) {
Node<K,V> n = (owned) node;
key = (owned) n.key;
value = (owned) n.value;