edu.washington.cs.cupid.internal.CapabilityRegistry.java Source code

Introduction

Here is the source code for edu.washington.cs.cupid.internal.CapabilityRegistry.java

Source

/*******************************************************************************
 * Copyright (c) 2013 Todd Schiller.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     Todd Schiller - initial API, implementation, and documentation
 ******************************************************************************/
package edu.washington.cs.cupid.internal;

import java.util.Set;
import java.util.SortedSet;

import com.google.common.base.Predicate;
import com.google.common.collect.Sets;
import com.google.common.reflect.TypeToken;

import edu.washington.cs.cupid.TypeManager;
import edu.washington.cs.cupid.capability.CapabilityUtil;
import edu.washington.cs.cupid.capability.ChangeNotifier;
import edu.washington.cs.cupid.capability.ICapability;
import edu.washington.cs.cupid.capability.ICapabilityChangeListener;
import edu.washington.cs.cupid.capability.ICapabilityPublisher;
import edu.washington.cs.cupid.capability.ICapabilityRegistry;
import edu.washington.cs.cupid.capability.exception.NoSuchCapabilityException;

/**
 * A thread-safe registry of the available Cupid capabilities.
 * @author Todd Schiller (tws@cs.washington.edu) 
 */
public final class CapabilityRegistry implements ICapabilityRegistry {

    /**
     * Set of available capabilities.
     */
    private final Set<ICapability> capabilities = Sets.newIdentityHashSet();

    /**
     * Set of change listeners.
     */
    private final ChangeNotifier notifier = new ChangeNotifier();

    @Override
    public void onCapabilityAdded(ICapability capability) {
        capabilities.add(capability);
        notifier.onCapabilityAdded(capability);
    }

    @Override
    public void onCapabilityRemoved(ICapability capability) {
        capabilities.remove(capability);
        notifier.onCapabilityRemoved(capability);
    }

    @Override
    public synchronized ICapability[] publish() {
        return capabilities.toArray(new ICapability[] {});
    }

    @Override
    public synchronized ICapability findCapability(final String name) throws NoSuchCapabilityException {
        for (ICapability capability : capabilities) {
            if (capability.getName().equals(name)) {
                return capability;
            }
        }
        throw new NoSuchCapabilityException(name);
    }

    @Override
    public synchronized SortedSet<ICapability> getCapabilities(final TypeToken<?> type) {
        SortedSet<ICapability> result = Sets.newTreeSet(CapabilityUtil.COMPARE_NAME);
        for (ICapability capability : capabilities) {
            for (ICapability.IParameter<?> param : capability.getParameters()) {
                if (TypeManager.isCompatible(param, type)) {
                    result.add(capability);
                    break;
                }
            }
        }
        return result;
    }

    @Override
    public synchronized SortedSet<ICapability> getCapabilities(final TypeToken<?> inputType,
            final TypeToken<?> outputType) {
        SortedSet<ICapability> result = Sets.newTreeSet(CapabilityUtil.COMPARE_NAME);

        for (ICapability capability : getCapabilities(inputType)) {
            for (ICapability.IOutput<?> output : capability.getOutputs()) {
                if (TypeManager.isJavaCompatible(outputType, output.getType())) {
                    result.add(capability);
                    break;
                }
            }
        }
        return result;
    }

    @Override
    public synchronized SortedSet<ICapability> getCapabilitiesForOutput(final TypeToken<?> outputType) {
        SortedSet<ICapability> result = Sets.newTreeSet(CapabilityUtil.COMPARE_NAME);

        for (ICapability capability : capabilities) {
            for (ICapability.IOutput<?> output : capability.getOutputs()) {
                if (TypeManager.isJavaCompatible(outputType, output.getType())) {
                    result.add(capability);
                    break;
                }
            }
        }
        return result;
    }

    @Override
    public SortedSet<ICapability> getCapabilities(Predicate<ICapability> filter) {
        SortedSet<ICapability> result = Sets.newTreeSet(CapabilityUtil.COMPARE_NAME);
        for (ICapability capability : capabilities) {
            if (filter.apply(capability)) {
                result.add(capability);
            }
        }
        return result;
    }

    @Override
    public synchronized SortedSet<ICapability> getPredicates() {
        SortedSet<ICapability> result = Sets.newTreeSet(CapabilityUtil.COMPARE_NAME);

        for (ICapability capability : capabilities) {
            Set<ICapability.IOutput<?>> bool = Sets.newHashSet();
            for (ICapability.IOutput<?> output : capability.getOutputs()) {
                if (TypeManager.isJavaCompatible(TypeToken.of(Boolean.class), output.getType())) {
                    bool.add(output);
                }
            }
            if (bool.size() == 1) {
                result.add(capability);
            }
        }
        return result;
    }

    @Override
    public synchronized SortedSet<ICapability> getCapabilities() {
        SortedSet<ICapability> result = Sets.newTreeSet(CapabilityUtil.COMPARE_NAME);
        result.addAll(capabilities);
        return result;
    }

    @Override
    public synchronized void addChangeListener(final ICapabilityChangeListener listener) {
        notifier.addChangeListener(listener);
    }

    @Override
    public synchronized void removeChangeListener(final ICapabilityChangeListener listener) {
        notifier.addChangeListener(listener);
    }

    @Override
    public synchronized void registerPublisher(final ICapabilityPublisher publisher) {
        publisher.addChangeListener(this);

        for (ICapability published : publisher.publish()) {
            if (published == null) {
                CupidActivator.getDefault().logError(
                        "Publisher published null capability: " + publisher.getClass().getName(),
                        new NullPointerException());
            } else if (published.getName() == null || published.getName().trim().isEmpty()) {
                CupidActivator.getDefault().logError(
                        "Publisher published capability without name: " + publisher.getClass().getName(),
                        new IllegalArgumentException());
            } else {
                capabilities.add(published);
                notifier.onCapabilityAdded(published);
            }
        }
    }

    @Override
    public void registerStaticCapability(final ICapability capability) {
        if (capability == null) {
            CupidActivator.getDefault().logError("Plug-in tried to register null capability",
                    new NullPointerException());
        } else {
            capabilities.add(capability);
            notifier.onCapabilityAdded(capability);
        }
    }

    @Override
    public ICapability getViewer(final TypeToken<?> type) {
        throw new UnsupportedOperationException();

        //      List<ViewRule> rules = new Gson().fromJson(
        //            preferences.getString(PreferenceConstants.P_TYPE_VIEWS),
        //            new com.google.gson.reflect.TypeToken<List<ViewRule>>() { } .getType());

        //      for (ViewRule rule : rules) {
        //         if (rule.isActive() && rule.getCapability() != null) {
        //            ICapability capability;
        //            try {
        //               capability = findCapability(rule.getCapability());
        //            } catch (NoSuchCapabilityException e) {
        //               continue;
        //            }
        //            
        //            if (TypeManager.isCompatible(capability, type)) {
        //               return capability;
        //            }
        //         }
        //      }
        //      return null;
    }
}