org.aksw.commons.collection.observable.ObservableConvertingCollection Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of aksw-commons-collections Show documentation
There is a newer version: 0.9.9
Show newest version
package org.aksw.commons.collection.observable;

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.beans.VetoableChangeListener;
import java.beans.VetoableChangeSupport;
import java.util.Collection;
import java.util.Collections;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.aksw.commons.collections.ConvertingCollection;

import com.google.common.base.Converter;


public class ObservableConvertingCollection>
    extends ConvertingCollection
    implements ObservableCollection
{
    protected VetoableChangeSupport vcs = new VetoableChangeSupport(this);
    protected PropertyChangeSupport pcs = new PropertyChangeSupport(this);

    public ObservableConvertingCollection(C backend, Converter converter) {
        super(backend, converter);
    }

    protected boolean isDuplicateAwareBackend() {
        return !(backend instanceof Set);
    }


    @Override
    public boolean delta(Collection rawAdditions, Collection rawRemovals) {
        Collection convertedRemovals = StreamOps.collect(false, ConvertingCollection.convertRaw(rawRemovals, converter.reverse()));
        Collection convertedAdditions = StreamOps.collect(false, ConvertingCollection.convertRaw(rawAdditions, converter.reverse()));

        return backend.delta(convertedAdditions, convertedRemovals);
    }

//    @Override
//    public boolean replace(Collection c) {
//        boolean isDuplicateAware = isDuplicateAwareBackend();
//        Stream itemStream = c.stream().map(converter.reverse()::convert);
//        Collection items = isDuplicateAware ? itemStream.collect(Collectors.toList()) : itemStream.collect(Collectors.toSet());
//
//        return backend.replace(items);
//
//    }

    @Override
    public boolean add(F value) {
        return addAll(Collections.singleton(value));
    }

    @Override
    public boolean addAll(Collection c) {
        boolean isDuplicateAware = isDuplicateAwareBackend();
        Stream itemStream = c.stream().map(converter.reverse()::convert);
        Collection items = isDuplicateAware ? itemStream.collect(Collectors.toList()) : itemStream.collect(Collectors.toSet());

        return backend.addAll(items);
    }

    @Override
    public boolean remove(Object value) {
        return removeAll(Collections.singleton(value));
    }

    @Override
    public boolean removeAll(Collection c) {
        boolean isDuplicateAware = isDuplicateAwareBackend();

        Stream itemStream = ConvertingCollection.convertRaw(c, converter.reverse());

        Collection items = isDuplicateAware ? itemStream.collect(Collectors.toList()) : itemStream.collect(Collectors.toSet());

        return backend.removeAll(items);
    }


    @Override
    public void clear() {
        backend.clear();
    }

//
//    @Override
//    public boolean addAll(Collection c) {
//        boolean result = false;
//
//        boolean isDuplicateAware = isDuplicateAwareBackend();
//
//        Stream itemStream = c.stream().map(converter.reverse()::convert);
//
//        Collection items = isDuplicateAware ? itemStream.collect(Collectors.toList()) : itemStream.collect(Collectors.toSet());
//
//        if (isDuplicateAwareBackend() || !backend.containsAll(items)) {
//            // Collection newItem = Collections.singleton(value);
//            {
//                Collection oldValue = this;
//                Collection newValue = CollectionOps.smartUnion(this, newItem);// CollectionFromIterable.wrap(Iterables.concat(this, newItem));
//
//                try {
//                    vcs.fireVetoableChange(new CollectionChangedEventImpl<>(
//                            this, oldValue, newValue,
//                            newItem, Collections.emptySet(), Collections.emptySet()));
//                } catch (PropertyVetoException e) {
//                    throw new RuntimeException(e);
//                }
//            }
//
//            result = backend.addAll(items);
//
//            {
//                Collection oldValue = CollectionOps.smartDifference(this, newItem);
//                Collection newValue = this;
//
//                pcs.firePropertyChange(new CollectionChangedEventImpl<>(
//                        this, oldValue, newValue,
//                        newItem, Collections.emptySet(), Collections.emptySet()));
//            }
//        }
//
//        return result;    }
//
//    @Override
//    public boolean add(F value) {
//        return addAll(Collections.singleton(value));
//    }
//
//    @Override
//    public boolean remove(Object o) {
//        boolean result = false;
//        try {
//            @SuppressWarnings("unchecked")
//            F frontendItem = (F)o;
//            B backendItem = converter.reverse().convert(frontendItem);
//
//            if (isDuplicateAwareBackend() || backend.contains(backendItem)) {
//                Collection removedItem = Collections.singleton(frontendItem);
//
//                {
//                    Collection oldValue = this;
//                    Collection newValue = CollectionFromIterable.wrap(() -> Iterators.filter(
//                            oldValue.iterator(),
//                            PredicateFromMultisetOfDiscardedItems.create(HashMultiset.create(removedItem))::test));
//
//                    try {
//                        vcs.fireVetoableChange(new CollectionChangedEventImpl<>(
//                                this, oldValue, newValue,
//                                Collections.emptySet(), removedItem, Collections.emptySet()));
//                    } catch (PropertyVetoException e) {
//                        throw new RuntimeException(e);
//                    }
//
//                }
//
//                result = backend.remove(backendItem);
//
//                {
//                    Collection oldValue = CollectionOps.smartUnion(this, removedItem);
//                    Collection newValue = this;
//
//                    pcs.firePropertyChange(new CollectionChangedEventImpl<>(
//                            this, oldValue, newValue,
//                            Collections.emptySet(), removedItem, Collections.emptySet()));
//                }
//
//            }
//
//        } catch(ClassCastException e) {
//            /* nothing to do */
//        }
//
//        return result;
//    }

    /** Used only in the event adaptions below*/
    protected static  Collection convert(Collection set, Converter converter) {
        return set == null ? null : ConvertingCollection.createSafe(set, converter);
    }

    @SuppressWarnings("unchecked")
    public static > CollectionChangedEvent convertEvent(Object self,
            CollectionChangedEvent ev, Converter converter) {
        return new CollectionChangedEventImpl(
            self,
            convert((Collection)ev.getOldValue(), converter),
            convert((Collection)ev.getNewValue(), converter),
            convert((Collection)ev.getAdditions(), converter),
            convert((Collection)ev.getDeletions(), converter),
            convert((Collection)ev.getRefreshes(), converter));
    }

    @Override
    public Runnable addVetoableChangeListener(VetoableChangeListener listener) {
        return getBackend().addVetoableChangeListener(ev -> {
            CollectionChangedEvent newEv = convertEvent(this, (CollectionChangedEvent)ev, converter);

            if (newEv.hasChanges()) {
                listener.vetoableChange(newEv);
            }
        });
    }

    @Override
    public Registration addPropertyChangeListener(PropertyChangeListener listener) {
        return getBackend().addPropertyChangeListener(ev -> {
            CollectionChangedEvent newEv = convertEvent(this, (CollectionChangedEvent)ev, converter);

            if (newEv.hasChanges()) {
                listener.propertyChange(newEv);
            }
        });
    }


}