Add SetBase/SetMixin.

sdk/lib/collection/splay_tree.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.collection;
 
 typedef bool _Predicate<T>(T value);
 
 /**
  * A node in a splay tree. It holds the sorting key and the left
@@ skipping 621 matching lines @@
  *
  * The set is based on a self-balancing binary tree. It allows most operations
  * in amortized logarithmic time.
  *
  * Elements of the set are compared using the `compare` function passed in
  * the constructor. If that is omitted, the objects are assumed to be
  * [Comparable], and are compared using their [Comparable.compareTo]
  * method. Non-comparable objects (including `null`) will not work as an element
  * in that case.
  */
-class SplayTreeSet<E> extends _SplayTree<E> with IterableMixin<E>
-                      implements Set<E> {
+class SplayTreeSet<E> extends _SplayTree<E> with IterableMixin<E>, SetMixin<E> {
   Comparator _comparator;
   _Predicate _validKey;
 
   /**
    * Create a new [SplayTreeSet] with the given compare function.
    *
    * If the [compare] function is omitted, it defaults to [Comparable.compare],
    * and the elements must be comparable.
    *
    * A provided `compare` function may not work on all objects. It may not even
@@ skipping 22 matching lines @@
 
   // From Iterable.
 
   Iterator<E> get iterator => new _SplayTreeKeyIterator<E>(this);
 
   int get length => _count;
   bool get isEmpty => _root == null;
   bool get isNotEmpty => _root != null;
 
   E get first {
-    if (_count == 0) throw new StateError("no such element");
+    if (_count == 0) throw IterableElementError.noElement();
     return _first.key;
   }
 
   E get last {
-    if (_count == 0) throw new StateError("no such element");
+    if (_count == 0) throw IterableElementError.noElement();
     return _last.key;
   }
 
   E get single {
-    if (_count == 0) throw new StateError("no such element");
-    if (_count > 1) throw new StateError("too many elements");
+    if (_count == 0) throw IterableElementError.noElement();
+    if (_count > 1) throw IterableElementError.tooMany();
     return _root.key;
   }
 
   // From Set.
   bool contains(Object object) {
     return _validKey(object) && _splay(object) == 0;
   }
 
   bool add(E element) {
     int compare = _splay(element);
@@ skipping 15 matching lines @@
       }
     }
   }
 
   void removeAll(Iterable<Object> elements) {
     for (Object element in elements) {
       if (_validKey(element)) _remove(element);
     }
   }
 
-  /**
-   * Removes all elements not in [elements].
-   */
   void retainAll(Iterable<Object> elements) {
     // Build a set with the same sense of equality as this set.
     SplayTreeSet<E> retainSet = new SplayTreeSet<E>(_comparator, _validKey);
     int modificationCount = _modificationCount;
     for (Object object in elements) {
       if (modificationCount != _modificationCount) {
         // The iterator should not have side effects.
         throw new ConcurrentModificationError(this);
       }
       // Equivalent to this.contains(object).
       if (_validKey(object) && _splay(object) == 0) retainSet.add(_root.key);
     }
     // Take over the elements from the retained set, if it differs.
     if (retainSet._count != _count) {
       _root = retainSet._root;
       _count = retainSet._count;
       _modificationCount++;
     }
   }
 
-  void _filterWhere(bool test(E element), bool removeMatching) {
-    _SplayTreeNodeIterator it = new _SplayTreeNodeIterator(this);
-    while (it.moveNext()) {
-      _SplayTreeNode node = it.current;
-      int modificationCount = _modificationCount;
-      bool matches = test(node.key);
-      if (modificationCount != _modificationCount) {
-        throw new ConcurrentModificationError(this);
-      }
-      if (matches == removeMatching) {
-        _remove(node.key);
-        it = new _SplayTreeNodeIterator.startAt(this, node.key);
-      }
-    }
-  }
-
-  void removeWhere(bool test(E element)) {
-    _filterWhere(test, true);
-  }
-
-  void retainWhere(bool test(E element)) {
-    _filterWhere(test, false);
-  }
-
   E lookup(Object object) {
     if (!_validKey(object)) return null;
     int comp = _splay(object);
     if (comp != 0) return null;
     return _root.key;
   }
 
-  Set<E> intersection(Set<E> other) {
-    Set<E> result = new SplayTreeSet<E>(_compare, _validKey);
-    for (E element in this) {
-      if (other.contains(element)) result.add(element);
-    }
-    return result;
-  }
-
-  Set<E> difference(Set<E> other) {
-    Set<E> result = new SplayTreeSet<E>(_compare, _validKey);
-    for (E element in this) {
-      if (!other.contains(element)) result.add(element);
-    }
-    return result;
-  }
-
-  Set<E> union(Set<E> other) {
-    return _clone()..addAll(other);
-  }
-
   SplayTreeSet<E> _clone() {
-    var set = new SplayTreeSet<E>(_compare, _validKey);
+    var set = new SplayTreeSet<E>(_comparator, _validKey);
     set._count = _count;
     set._root = _cloneNode(_root);
     return set;
   }
 
   _SplayTreeNode<E> _cloneNode(_SplayTreeNode<E> node) {
     if (node == null) return null;
     return new _SplayTreeNode<E>(node.key)..left = _cloneNode(node.left)
                                           ..right = _cloneNode(node.right);
   }
 
-  bool containsAll(Iterable<Object> other) {
-    for (var element in other) {
-      if (!this.contains(element)) return false;
-    }
-    return true;
-  }
+  void clear() { _clear(); }
 
-  void clear() { _clear(); }
+  Set<E> toSet() => _clone();
 }