FastCollection.java

Go to the documentation of this file.

/*
 * Javolution - Java(TM) Solution for Real-Time and Embedded Systems
 * Copyright (C) 2012 - Javolution (http://javolution.org/)
 * All rights reserved.
 * 
 * Permission to use, copy, modify, and distribute this software is
 * freely granted, provided that this notice is preserved.
 */
package javolution.util;
 
import static javolution.lang.Realtime.Limit.CONSTANT;
import static javolution.lang.Realtime.Limit.LINEAR;
import static javolution.lang.Realtime.Limit.N_SQUARE;
 
import java.io.IOException;
import java.io.Serializable;
import java.util.Collection;
import java.util.Comparator;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
 
import javolution.lang.Immutable;
import javolution.lang.Parallelizable;
import javolution.lang.Realtime;
import javolution.text.Cursor;
import javolution.text.DefaultTextFormat;
import javolution.text.TextContext;
import javolution.text.TextFormat;
import javolution.util.function.Consumer;
import javolution.util.function.Equalities;
import javolution.util.function.Equality;
import javolution.util.function.Function;
import javolution.util.function.Predicate;
import javolution.util.function.Reducer;
import javolution.util.function.Reducers;
import javolution.util.internal.collection.AtomicCollectionImpl;
import javolution.util.internal.collection.DistinctCollectionImpl;
import javolution.util.internal.collection.FilteredCollectionImpl;
import javolution.util.internal.collection.MappedCollectionImpl;
import javolution.util.internal.collection.ParallelCollectionImpl;
import javolution.util.internal.collection.ReversedCollectionImpl;
import javolution.util.internal.collection.SequentialCollectionImpl;
import javolution.util.internal.collection.SharedCollectionImpl;
import javolution.util.internal.collection.SortedCollectionImpl;
import javolution.util.internal.collection.UnmodifiableCollectionImpl;
import javolution.util.service.CollectionService;
 
@Realtime
@DefaultTextFormat(FastCollection.Format.class)
public abstract class FastCollection<E> implements Collection<E>, Serializable {
 
    private static final long serialVersionUID = 0x600L; // Version.
 
    protected FastCollection() {}
 
    // Views.
    //
 
    @Parallelizable(mutexFree = true, comment = "Except for write operations, all read operations are mutex-free.")
    public FastCollection<E> atomic() {
        return new AtomicCollectionImpl<E>(service());
    }
 
    @Parallelizable(mutexFree = false, comment = "Use multiple-readers/single-writer lock.")
    public FastCollection<E> shared() {
        return new SharedCollectionImpl<E>(service());
    }
 
    public FastCollection<E> parallel() {
        return new ParallelCollectionImpl<E>(service());
    }
 
    public FastCollection<E> sequential() {
        return new SequentialCollectionImpl<E>(service());
    }
 
    public FastCollection<E> unmodifiable() {
        return new UnmodifiableCollectionImpl<E>(service());
    }
 
    public FastCollection<E> filtered(Predicate<? super E> filter) {
        return new FilteredCollectionImpl<E>(service(), filter);
    }
 
    public <R> FastCollection<R> mapped(
            Function<? super E, ? extends R> function) {
        return new MappedCollectionImpl<E, R>(service(), function);
    }
 
    public FastCollection<E> sorted() {
        return new SortedCollectionImpl<E>(service(), comparator());
    }
 
    public FastCollection<E> sorted(Comparator<? super E> cmp) {
        return new SortedCollectionImpl<E>(service(), cmp);
    }
 
    public FastCollection<E> reversed() {
        return new ReversedCollectionImpl<E>(service());
    }
 
    public FastCollection<E> distinct() {
        return new DistinctCollectionImpl<E>(service());
    }
 
    // Closure operations.
    //
 
    @SuppressWarnings("unchecked")
    @Realtime(limit = LINEAR)
    public void perform(Consumer<? extends Collection<E>> action) {
        service().perform((Consumer<CollectionService<E>>) action, service());
    }
 
    @SuppressWarnings("unchecked")
    @Realtime(limit = LINEAR)
    public void update(Consumer<? extends Collection<E>> action) {
        service().update((Consumer<CollectionService<E>>) action, service());
    }
 
    @Realtime(limit = LINEAR)
    public void forEach(final Consumer<? super E> consumer) {
        perform(new Consumer<Collection<E>>() {
            public void accept(Collection<E> view) {
                Iterator<E> it = view.iterator();
                while (it.hasNext()) {
                    consumer.accept(it.next());
                }
            }
        });
    }
 
    @Realtime(limit = LINEAR)
    public boolean removeIf(final Predicate<? super E> filter) {
        final boolean[] removed = new boolean[1];
        update(new Consumer<Collection<E>>() {
            public void accept(Collection<E> view) {
                Iterator<E> it = view.iterator();
                while (it.hasNext()) {
                    if (filter.test(it.next())) {
                        it.remove(); // Ok mutable iteration.
                        removed[0] = true;
                    }
                }
            }
        });
        return removed[0];
    }
 
    @Realtime(limit = LINEAR)
    public E reduce(Reducer<E> reducer) {
        perform(reducer);
        return reducer.get();
    }
 
    // Collection operations.
    //
 
    @Override
    @Realtime(limit = LINEAR, comment = "May have to search the whole collection (e.g. distinct view).")
    public boolean add(E element) {
        return service().add(element);
    }
 
    @Override
    @Realtime(limit = LINEAR, comment = "May actually iterates the whole collection (e.g. filtered view).")
    public boolean isEmpty() {
        return iterator().hasNext();
    }
 
    @Override
    @Realtime(limit = LINEAR, comment = "Potentially counts the elements.")
    public int size() {
        return service().size();
    }
 
    @Override
    @Realtime(limit = LINEAR, comment = "Potentially removes elements one at a time.")
    public void clear() {
        service().clear();
    }
 
    @Override
    @Realtime(limit = LINEAR, comment = "Potentially searches the whole collection.")
    public boolean contains(Object searched) {
        return service().contains(searched);
    }
 
    @Override
    @Realtime(limit = LINEAR, comment = "Potentially searches the whole collection.")
    public boolean remove(Object searched) {
        return service().remove(searched);
    }
 
    @Override
    @Realtime(limit = N_SQUARE, comment = "Construction of the iterator may require sorting the elements (e.g. sorted view)")
    public Iterator<E> iterator() {
        return service().iterator();
    }
 
    @Override
    @Realtime(limit = LINEAR)
    public boolean addAll(final Collection<? extends E> that) {
        return service().addAll(that);
    }
 
    @Override
    @Realtime(limit = N_SQUARE)
    public boolean containsAll(Collection<?> that) {
        return service().containsAll(that);
    }
 
    @Override
    @Realtime(limit = N_SQUARE)
    public boolean removeAll(final Collection<?> that) {
        return service().removeAll(that);
    }
 
    @Override
    @Realtime(limit = N_SQUARE)
    public boolean retainAll(final Collection<?> that) {
        return service().retainAll(that);
    }
 
    @Override
    @Realtime(limit = LINEAR)
    public Object[] toArray() {
        return service().toArray();
    }
 
    @Override
    @Realtime(limit = LINEAR)
    public <T> T[] toArray(final T[] array) {
        return service().toArray(array);
    }
 
    // Misc.
    //
 
    @SuppressWarnings("unchecked")
    @Realtime(limit = LINEAR)
    public <T extends E> T any(Class<T> type) {
        return (T) reduce((Reducer<E>) Reducers.any(type));
    }
 
    @Realtime(limit = LINEAR)
    public E min() {
        return reduce(Reducers.min(comparator()));
    }
 
    @Realtime(limit = LINEAR)
    public E max() {
        return reduce(Reducers.max(comparator()));
    }
 
    @Realtime(limit = LINEAR)
    public FastCollection<E> addAll(E... elements) {
        for (E e : elements) {
            add(e);
        }
        return this;
    }
 
    @Realtime(limit = LINEAR)
    public FastCollection<E> addAll(FastCollection<? extends E> that) {
        addAll((Collection<? extends E>) that);
        return this;
    }
 
    @Realtime(limit = CONSTANT)
    public Equality<? super E> comparator() {
        return service().comparator();
    }
 
    @Realtime(limit = CONSTANT)
    public <T extends Collection<E>> Immutable<T> toImmutable() {
        return new Immutable<T>() {
            @SuppressWarnings("unchecked")
            final T value = (T) unmodifiable();
 
            @Override
            public T value() {
                return value;
            }
 
        };
    }
 
    @Override
    @Realtime(limit = LINEAR)
    public boolean equals(Object obj) {
        return service().equals(obj);
    }
 
    @Override
    @Realtime(limit = LINEAR)
    public int hashCode() {
        return service().hashCode();
    }
 
    @Override
    @Realtime(limit = LINEAR)
    public String toString() {
        return TextContext.getFormat(FastCollection.class).format(this);
    }
 
    protected abstract CollectionService<E> service();
 
    protected static <E> CollectionService<E> serviceOf(
            FastCollection<E> collection) {
        return collection.service();
    }
 
    // Textual format.
    //
 
    @Parallelizable
    public static class Format extends TextFormat<FastCollection<?>> {
 
        @Override
        public FastCollection<Object> parse(CharSequence csq, Cursor cursor)
                throws IllegalArgumentException {
            throw new UnsupportedOperationException();
        }
 
        @Override
        public Appendable format(FastCollection<?> that, final Appendable dest)
                throws IOException {
            dest.append('[');
            Class<?> elementType = null;
            TextFormat<Object> format = null;
            for (Object element : that) {
                if (elementType == null) elementType = Void.class; 
                else dest.append(", "); // Not the first.
                if (element == null) {
                    dest.append("null");
                    continue;
                }
                Class<?> cls = element.getClass();
                if (elementType.equals(cls)) {
                    format.format(element, dest);
                    continue;
                }
                elementType = cls;
                format = TextContext.getFormat(cls);
                format.format(element, dest);
            }
            return dest.append(']');
        }
 
    }
 
}