Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2006-2007 the original author or authors.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package org.codehaus.mojo.groovy.runtime.loader;
 
 import java.util.Map;
 import java.util.Set;
 
???

Author(s):
Jason Dillon
Version:
$Id: DefaultProviderSelector.java 5554 2007-10-25 17:12:34Z user57 $
Plexus.component:
role="org.codehaus.mojo.groovy.feature.ProviderSelector" instantiation-strategy="singleton"
 
 public class DefaultProviderSelector
     extends LoaderSupport
     implements ProviderSelector
 {
     public Provider select(final ProviderRegistry registryfinal String selectionthrows Exception {
         assert registry != null;
         assert selection != null;
 
         .trace("Select: {}"selection);
 
         register(registryselection);
 
         Provider provider = null;
 
         if (.equals(selection)) {
             provider = selectAny(registry);
         }
         else {
             String[] keys = selection.split(",");
 
             for (int i=0; i<keys.lengthi++) {
                 Provider tmp = registry.lookup(keys[i]);
                 
                 if (tmp != null) {
                     provider = tmp;
                     break;
                 }
             }
         }
 
         if (.isTraceEnabled()) {
             if (provider == null) {
                 .trace("No matching providers found for selection: {}"selection);
             }
             else if (!provider.supported()) {
                 .trace("Found unsupported provider matching selection: {}, found: {}"selectionprovider);
             }
         }
         
         return provider;
     }
 
     private Provider selectAny(final ProviderRegistry registry) {
         assert registry != null;
 
         Map supported = registry.providers(true);
 
         Provider provider = null;
 
         if (supported != null && !supported.isEmpty()) {
             provider = (Providersupported.values().iterator().next();
         }
 
         return provider;
     }
 
     private void register(final ProviderRegistry registryfinal String selectionthrows Exception {
         assert registry != null;
         assert selection != null;
 
         // First run discovery
         Map discovered = discover(registryselection);
 
        // If we didn't find anything then puke
        if (discovered == null || discovered.isEmpty()) {
            .debug("No providers discovered for selection: {}"selection);
        }
        else {
            .debug("Registering {} providers:", String.valueOf(discovered.size()));
            for (Iterator iter = discovered.keySet().iterator(); iter.hasNext();) {
                String key = (Stringiter.next();
                Provider provider = (Providerdiscovered.get(key);
                .debug("    {} -> {}"keyprovider);
                // Complain if we found a mismatch of keys
                if (!key.equals(provider.key())) {
                    .warn("Found mismatch of provider key; discovered key: {}, provider's key: {}"keyprovider.key());
                }
                Provider replaced = registry.register(provider);
                // Complain if we replaced a provider
                if (replaced != null) {
                    .warn("Replaced provider; key: {}, current: {}, replaced: {}"new Object[] { keyproviderreplaced });
                }
            }
        }
    }
    private Map discover(final ProviderRegistry registryfinal String selectionthrows Exception {
        assert registry != null;
        assert selection != null;
        .debug("Discovering providers for selection: {}"selection);
        Map discovered = null;
        String[] keys = selection.split(",");
        // Attempt to discover providers for each key
        for (int i=0; i<keys.lengthi++) {
            // Don't attempt to discover psuedo providers
            if (keys[i].equals()) {
                continue;
            }
            try {
                // First see if the registry already has a provider for this key
                if (registry.lookup(keys[i]) != null) {
                    .debug("Provider already registered for: {}"keys[i]);
                    // Skip loading and re-use the registered provider
                    continue;
                }
                Map found = load(keys[i]);
                if (found != null && !found.isEmpty()) {
                    // Late init the discovered providers map
                    if (discovered == null) {
                        discovered = new HashMap();
                    }
                    discovered.putAll(found);
                }
            }
            catch (Exception e) {
                .debug("Failed to load providers for key: {}"keys[i], e);
            }
        }
        return discovered;
    }
    protected Map load(final String keythrows Exception {
        assert key != null;
        Map found = null;
        Map loaders = findLoaders();
        if (loaders == null || loaders.isEmpty()) {
            .debug("No provider loaders were found");
        }
        else {
            .debug("Looking for provider {} in {}"keyloaders);
            for (Iterator iter = loaders.values().iterator(); iter.hasNext();) {
                ProviderLoader loader = (ProviderLoaderiter.next();
                .debug("Trying to load {} from {}"keyloader);
                try {
                    Map loaded = loader.load(key);
                    if (loaded != null && !loaded.isEmpty()) {
                        found = loaded;
                        break;
                    }
                }
                catch (Exception e) {
                    .warn("Failed to load provider from: {}"loadere);
                }
            }
        }
        return found;
    }

    
Find any provider loaders which are available in the container.
    private Map findLoaders() {
        Map found = null;
        for (Iterator iter = keys.iterator(); iter.hasNext();) {
            String key = (String)iter.next();
            ProviderLoader loader;
            
            try {
                loader = (ProviderLoadergetContainer().lookup(ProviderLoader.class.getName(), key);
            }
            catch (Exception e) {
                .warn("Failed to lookup provider loader for key: {}"keye);
                continue;
            }
            if (loader != null) {
                if (found == null) {
                    found = new HashMap();
                }
                found.put(keyloader);
            }
        }
        return found;
    }
New to GrepCode? Check out our FAQ X