ObservableTest.java

import java.util.HashSet;
import java.util.Set;

import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.set.ComputedSet;
import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.observable.set.ISetChangeListener;
import org.eclipse.core.databinding.observable.set.SetChangeEvent;
import org.eclipse.core.databinding.observable.set.UnionSet;
import org.eclipse.core.databinding.observable.set.WritableSet;

public class ObservableTest {

    
    public static class DefaultRealm extends Realm {
        private Realm previousRealm;

        public DefaultRealm() {
            previousRealm = super.setDefault(this);
        }

        /**
         * @return always returns true
         */
        public boolean isCurrent() {
            return true;
        }

        protected void syncExec(Runnable runnable) {
            runnable.run();
        }

        /**
         * @throws UnsupportedOperationException
         */
        public void asyncExec(Runnable runnable) {
            throw new UnsupportedOperationException("asyncExec is unsupported");
        }

        /**
         * Removes the realm from being the current and sets the previous realm to the default.
         */
        public void dispose() {
            if (getDefault() == this) {
                setDefault(previousRealm);
            }
        }
    }
    
    /**
     * @param args
     */
    public static void main(String[] args) {
        new DefaultRealm();
        
        testingObservableSets(false);
// OUTPUT:
//        2
//        listeners added
//        [comp] additions size: 0 removals size: 0
//        0 added
//        [comp] additions size: 1 removals size: 0
//        4 added
//        end
        
        testingObservableSets(true);
// OUTPUT:
//        2
//        1
//        2
//        2
//        listeners added
//        [comp] additions size: 0 removals size: 0
//        [union] additions size: 1 removals size: 0
//        0 added
//        [union] additions size: 1 removals size: 0
//        4 added
//        end
    }

    private static void testingObservableSets(boolean useUnionSet) {
        final IObservableSet set = new WritableSet();
        set.add(Integer.valueOf(1));
        set.add(Integer.valueOf(2));
        ComputedSet comp = new ComputedSet() {
            
            @Override
            protected Set calculate() {
                Set<Integer> result = new HashSet<Integer>();
                for (Object _o : set) {
                    Integer i = (Integer)_o;
                    if (i > 1) {
                        result.add(i);
                    }
                }
                return result;
            }
        };
        for(Object o : comp) {
            System.out.println(o);
        
        }
        comp.addSetChangeListener(new ISetChangeListener() {
            
            @Override
            public void handleSetChange(SetChangeEvent event) {
                System.out.printf("[comp] additions size: %d removals size: %d\n", event.diff.getAdditions().size(), event.diff.getRemovals().size());
                
            }
        });
        
        if(useUnionSet) {
            UnionSet union = new UnionSet(new IObservableSet[]{set});
            for(Object o : union) {
                System.out.println(o);
                
            }
            union.addSetChangeListener(new ISetChangeListener() {
                
                @Override
                public void handleSetChange(SetChangeEvent event) {
                    System.out.printf("[union] additions size: %d removals size: %d\n", event.diff.getAdditions().size(), event.diff.getRemovals().size());
                    
                }
            });
            
            UnionSet unionOfComp = new UnionSet(new IObservableSet[]{comp});
            for(Object o : unionOfComp) {
                System.out.println(o);
            
            }
            unionOfComp.addSetChangeListener(new ISetChangeListener() {
                
                @Override
                public void handleSetChange(SetChangeEvent event) {
                    System.out.printf("[unionOfComp] additions size: %d removals size: %d\n", event.diff.getAdditions().size(), event.diff.getRemovals().size());
                    
                }
            });
        }
        
        System.out.println("listeners added");
        set.add(Integer.valueOf(0));
        System.out.println("0 added");
        set.add(Integer.valueOf(4));
        System.out.println("4 added");
        System.out.println("end");
    }

}