}

    @Override
    public Iterator<T> iterator() {
        return new IteratorImpl(store.iterator());
    }

    Iterator<T> iteratorNoFlush() {
        if (store.constantTimeIsEmpty()) {
            return Collections.emptyIterator();
        }

        return new IteratorImpl(store.iteratorNoFlush());
    }

    @Override
    public void all(Action<? super T> action) {

                }
            }
            return true;
        } else {
            return false;
        }
    }

    @Override
    public boolean constantTimeIsEmpty() {
        return collection.constantTimeIsEmpty();
    }

    @Override
    public boolean isEmpty() {
        if (collection.isEmpty()) {
            return true;
        } else {
            for (T o : this) {

     */
    Iterator<T> iteratorNoFlush();

    /**
     * Returns false if this source is not empty or it is not fast to determine this.
     */
    boolean constantTimeIsEmpty();

    @Override
    int estimatedSize();

    boolean contains(Object element);

    boolean containsAll(Collection<?> elements);

    @Override
    boolean isEmpty();

        this.values = new TreeSet<T>(comparator);
    }

    @Override
    public boolean isEmpty() {
        return values.isEmpty() && pending.isEmpty();
    }

    @Override
    public boolean constantTimeIsEmpty() {
        return values.isEmpty() && pending.isEmpty();
    }

    @Override
    public int size() {
        int pendingSize = 0;
        for (Collectors.TypedCollector<T> collector : pending) {

                if (next == collection) {
                    iterator.remove();
                    break;
                }
            }
        }

        @Override
        public boolean constantTimeIsEmpty() {
            return store.isEmpty();
        }

        @Override
        public int estimatedSize() {
            int size = 0;
            for (DomainObjectCollection<? extends T> ts : store) {

        for (Element<T> element : inserted) {
            if (element.size() != 0) {
                return false;
            }
        }
        return true;
    }

    @Override
    public boolean constantTimeIsEmpty() {
        return inserted.isEmpty();
    }

    @Override
    public int size() {
        int count = 0;
        for (Element<T> element : inserted) {
            count += element.size();
        }