public Type element_type {
get { return typeof (G); }
}
-
- public Gee.Iterator<A> stream<A> (owned StreamFunc<A, G> f) {
- return Gee.Iterator.stream_impl<G, A>(this, (owned)f);
- }
}
}
}
_index = _list._size;
}
-
- public Gee.Iterator<A> stream<A> (owned StreamFunc<A, G> f) {
- return Gee.Iterator.stream_impl<G, A>(this, (owned)f);
- }
}
}
}
}
- public Gee.Iterator<A> stream<A> (owned StreamFunc<G, A> f) {
- return Gee.Iterator.stream_impl<G, A> (this, (owned)f);
- }
-
private ArrayQueue _queue;
private int _stamp;
private int _offset = -1;
}
}
- public Gee.Iterator<G> stream<A> (owned StreamFunc<G, A> f) {
- return Gee.Iterator.stream_impl<G, A> (this, (owned)f);
- }
-
private bool _started;
private bool _removed;
private int _index;
break;
} while(true);
}
-
- public Gee.Iterator<A> stream<A> (owned StreamFunc<A, K> f) {
- return Gee.Iterator.stream_impl<K, A>(this, (owned)f);
- }
}
private class MapIterator<K,V> : NodeIterator<K,V>, Gee.MapIterator<K,V> {
break;
} while(true);
}
-
- public Gee.Iterator<A> stream<A> (owned StreamFunc<A, V> f) {
- return Gee.Iterator.stream_impl<V, A>(this, (owned)f);
- }
}
private class EntryIterator<K,V> : NodeIterator<K,V>, Traversable<Map.Entry<K,V>>, Iterator<Map.Entry<K,V>> {
break;
} while(true);
}
-
- public Gee.Iterator<A> stream<A> (owned StreamFunc<Map.Entry<K,V>, A> f) {
- return Gee.Iterator.stream_impl<Map.Entry<K,V>, A>(this, (owned)f);
- }
}
}
}
}
}
-
- public Gee.Iterator<A> stream<A> (owned StreamFunc<A, G> f) {
- return Gee.Iterator.stream_impl<G, A>(this, (owned)f);
- }
}
}
*/
public interface Gee.Iterable<G> : Object, Traversable<G> {
/**
- * The type of the elements in this collection.
- */
- public abstract Type element_type { get; }
-
- /**
* Returns a {@link Iterator} that can be used for simple iteration over a
* collection.
*
public abstract bool read_only { get; }
/**
- * Default implementation of {@link Traversable.stream}.
- *
- * @param self Current Iterator
- * @param f Stream function
- * @return Transformed stream
- * @see Traversable.stream
- */
- public static Iterator<A> stream_impl<G, A> (Iterator<G> self, owned StreamFunc<G, A> f) {
- Traversable.Stream str;
- Lazy<A>? initial = null;
- bool need_next = true;
- str = f (Traversable.Stream.YIELD, null, out initial);
- switch (str) {
- case Traversable.Stream.CONTINUE:
- if (self.valid) {
- str = f (Traversable.Stream.CONTINUE, new Lazy<G> (() => {return self.get ();}), out initial);
- switch (str) {
- case Traversable.Stream.YIELD:
- case Traversable.Stream.CONTINUE:
- break;
- case Traversable.Stream.END:
- return unfold<A> (() => {return null;});
- default:
- assert_not_reached ();
- }
- }
- break;
- case Traversable.Stream.YIELD:
- if (self.valid)
- need_next = false;
- break;
- case Traversable.Stream.END:
- return unfold<A> (() => {return null;});
- default:
- assert_not_reached ();
- }
- return unfold<A> (() => {
- Lazy<A>? val = null;
- if (str != Traversable.Stream.CONTINUE)
- str = f (Traversable.Stream.YIELD, null, out val);
- while (str == Traversable.Stream.CONTINUE) {
- if (need_next) {
- if (!self.next ()) {
- str = f (Traversable.Stream.END, null, out val);
- assert (str != Traversable.Stream.CONTINUE);
- break;
- }
- } else {
- need_next = true;
- }
- str = f (Traversable.Stream.CONTINUE, new Lazy<G> (() => {return self.get ();}), out val);
- }
- switch (str) {
- case Traversable.Stream.YIELD:
- return val;
- case Traversable.Stream.END:
- return null;
- default:
- assert_not_reached ();
- }
- }, initial);
- }
-
- /**
* Create iterator from unfolding function. The lazy value is
* force-evaluated before progressing to next element.
*
}
position = _list._tail;
}
-
- public Gee.Iterator<A> stream<A> (owned StreamFunc<A, G> f) {
- return Gee.Iterator.stream_impl<G, A>(this, (owned)f);
- }
}
private unowned Node<G>? _get_node_at (int index) {
while (next ())
f (position.data);
}
-
- public Gee.Iterator<A> stream<A> (owned StreamFunc<A, G> f) {
- return Gee.Iterator.stream_impl<G, A>(this, (owned)f);
- }
}
}
* @param f function generating stream
* @return iterator containing values yielded by stream
*/
- public abstract Iterator<A> stream<A> (owned StreamFunc<G, A> f);
+ public virtual Iterator<A> stream<A> (owned StreamFunc<G, A> f) {
+ Iterator<G>? self;
+ Iterable<G>? iself;
+ // Yes - I've heard of polimorphism ;) but I don't want users to need to implement the method.
+ if ((self = this as Iterator<G>) != null) {
+ Traversable.Stream str;
+ Lazy<A>? initial = null;
+ bool need_next = true;
+ str = f (Stream.YIELD, null, out initial);
+ switch (str) {
+ case Stream.CONTINUE:
+ if (self.valid) {
+ str = f (Stream.CONTINUE, new Lazy<G> (() => {return self.get ();}), out initial);
+ switch (str) {
+ case Stream.YIELD:
+ case Stream.CONTINUE:
+ break;
+ case Stream.END:
+ return Iterator.unfold<A> (() => {return null;});
+ default:
+ assert_not_reached ();
+ }
+ }
+ break;
+ case Stream.YIELD:
+ if (self.valid)
+ need_next = false;
+ break;
+ case Stream.END:
+ return Iterator.unfold<A> (() => {return null;});
+ default:
+ assert_not_reached ();
+ }
+ return Iterator.unfold<A> (() => {
+ Lazy<A>? val = null;
+ if (str != Stream.CONTINUE)
+ str = f (Traversable.Stream.YIELD, null, out val);
+ while (str == Stream.CONTINUE) {
+ if (need_next) {
+ if (!self.next ()) {
+ str = f (Traversable.Stream.END, null, out val);
+ assert (str != Traversable.Stream.CONTINUE);
+ break;
+ }
+ } else {
+ need_next = true;
+ }
+ str = f (Stream.CONTINUE, new Lazy<G> (() => {return self.get ();}), out val);
+ }
+ switch (str) {
+ case Stream.YIELD:
+ return val;
+ case Stream.END:
+ return null;
+ default:
+ assert_not_reached ();
+ }
+ }, initial);
+ } else if ((iself = this as Iterable<G>) != null) {
+ return iself.iterator().stream<A> ((owned) f);
+ } else {
+ assert_not_reached ();
+ }
+ }
/**
* Standard aggregation function.
});
}
+
+ /**
+ * The type of the elements in this collection.
+ */
+ public virtual Type element_type { get { return typeof (G); } }
+
public enum Stream {
YIELD,
CONTINUE,
for (; current != null; current = current.next)
f (current.key);
}
-
- public Gee.Iterator<A> stream<A> (owned StreamFunc<A, K> f) {
- return Gee.Iterator.stream_impl<K, A>(this, (owned)f);
- }
}
private class SubKeyIterator<K,V> : SubNodeIterator<K,V>, Traversable<K>, Gee.Iterator<K>, BidirIterator<K> {
while (iterator.next ())
f (iterator.current.key);
}
-
- public Gee.Iterator<A> stream<A> (owned StreamFunc<A, K> f) {
- return Gee.Iterator.stream_impl<K, A>(this, (owned)f);
- }
}
private class ValueIterator<K,V> : NodeIterator<K,V>, Traversable<V>, Gee.Iterator<V>, Gee.BidirIterator<V> {
for (; current != null; current = current.next)
f (current.key);
}
-
- public Gee.Iterator<A> stream<A> (owned StreamFunc<A, V> f) {
- return Gee.Iterator.stream_impl<V, A>(this, (owned)f);
- }
}
private class SubValueIterator<K,V> : SubNodeIterator<K,V>, Traversable<V>, Gee.Iterator<V>, BidirIterator<V> {
while (iterator.next ())
f (iterator.current.key);
}
-
- public Gee.Iterator<A> stream<A> (owned StreamFunc<A, V> f) {
- return Gee.Iterator.stream_impl<V, A>(this, (owned)f);
- }
}
private class EntryIterator<K,V> : NodeIterator<K,V>, Traversable<Map.Entry<K, V>>, Gee.Iterator<Map.Entry<K,V>>, Gee.BidirIterator<Map.Entry<K,V>> {
for (; current != null; current = current.next)
f (Entry.entry_for<K,V> (current));
}
-
- public Gee.Iterator<A> stream<A> (owned StreamFunc<Map.Entry<K, V>, A> f) {
- return Gee.Iterator.stream_impl<Map.Entry<K, V>, A>(this, (owned)f);
- }
}
private class SubEntryIterator<K,V> : SubNodeIterator<K,V>, Traversable<Map.Entry<K, V>>, Gee.Iterator<Map.Entry<K,V>>, Gee.BidirIterator<Map.Entry<K,V>> {
while (iterator.next ())
f (Entry.entry_for<K,V> (iterator.current));
}
-
- public Gee.Iterator<A> stream<A> (owned StreamFunc<Map.Entry<K, V>, A> f) {
- return Gee.Iterator.stream_impl<Map.Entry<K, V>, A>(this, (owned)f);
- }
}
private class MapIterator<K,V> : NodeIterator<K,V>, Gee.MapIterator<K,V>, BidirMapIterator<K,V> {
}
}
- public Gee.Iterator<A> stream<A> (owned StreamFunc<A, G> f) {
- return Gee.Iterator.stream_impl<G, A>(this, (owned)f);
- }
-
private weak Node<G>? current = null;
private weak Node<G>? _next = null;
private weak Node<G>? _prev = null;
f(get());
}
- public Gee.Iterator<A> stream<A> (owned StreamFunc<A, G> f) {
- return Gee.Iterator.stream_impl<G, A>(this, (owned)f);
- }
-
private new TreeSet<G> set;
private Range<G> range;
private Iterator<G>? iterator = null;
_end = true;
}
- public Iterator<A> stream<A> (owned StreamFunc<A, G> f) {
- return Iterator.stream_impl<G, A>(this, (owned)f);
- }
-
private UnfoldFunc<G> _func;
private Lazy<G>? _current;
private Lazy<G>? _next;
assert (test_collection != null);
Value value;
- value = Value (typeof (Type));
- test_collection.get_property ("element-type", ref value);
- assert (value.get_gtype () == test_collection.element_type);
- value.unset ();
-
value = Value (typeof (int));
test_collection.get_property ("size", ref value);
assert (value.get_int () == test_collection.size);
projects / platform / upstream / libgee.git / commitdiff