Coverage Report - org.codehaus.plexus.component.repository.DefaultComponentRepository
 
Classes in this File Line Coverage Branch Coverage Complexity
DefaultComponentRepository
84 %
63/75
69 %
32/46
4,375
 
 1  
 package org.codehaus.plexus.component.repository;
 2  
 
 3  
 /*
 4  
  * Copyright 2001-2006 Codehaus Foundation.
 5  
  *
 6  
  * Licensed under the Apache License, Version 2.0 (the "License");
 7  
  * you may not use this file except in compliance with the License.
 8  
  * You may obtain a copy of the License at
 9  
  *
 10  
  *      http://www.apache.org/licenses/LICENSE-2.0
 11  
  *
 12  
  * Unless required by applicable law or agreed to in writing, software
 13  
  * distributed under the License is distributed on an "AS IS" BASIS,
 14  
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 15  
  * See the License for the specific language governing permissions and
 16  
  * limitations under the License.
 17  
  */
 18  
 
 19  
 import static org.codehaus.plexus.component.CastUtils.isAssignableFrom;
 20  
 
 21  
 import java.util.ArrayList;
 22  
 import java.util.Collection;
 23  
 import java.util.HashSet;
 24  
 import java.util.LinkedHashMap;
 25  
 import java.util.List;
 26  
 import java.util.Map;
 27  
 import java.util.Set;
 28  
 import java.util.SortedMap;
 29  
 import java.util.TreeMap;
 30  
 
 31  
 import org.codehaus.plexus.ClassRealmUtil;
 32  
 import org.codehaus.plexus.PlexusConstants;
 33  
 import org.codehaus.plexus.classworlds.realm.ClassRealm;
 34  
 import org.codehaus.plexus.component.composition.CycleDetectedInComponentGraphException;
 35  
 import org.codehaus.plexus.component.composition.CompositionResolver;
 36  
 import org.codehaus.plexus.component.composition.DefaultCompositionResolver;
 37  
 import org.codehaus.plexus.logging.AbstractLogEnabled;
 38  
 import org.codehaus.plexus.util.StringUtils;
 39  
 
 40  
 import com.google.common.collect.LinkedHashMultimap;
 41  
 import com.google.common.collect.Multimap;
 42  
 import com.google.common.collect.Multimaps;
 43  
 
 44  
 /**
 45  
  * @author Jason van Zyl
 46  
  */
 47  
 public class DefaultComponentRepository
 48  
     extends AbstractLogEnabled
 49  
     implements ComponentRepository
 50  
 {
 51  61
     private final Map<ClassRealm, SortedMap<String, Multimap<String, ComponentDescriptor<?>>>> index = new LinkedHashMap<ClassRealm, SortedMap<String, Multimap<String, ComponentDescriptor<?>>>>();
 52  
 
 53  61
     private final CompositionResolver compositionResolver = new DefaultCompositionResolver();
 54  
 
 55  
     public DefaultComponentRepository()
 56  61
     {
 57  61
     }
 58  
 
 59  
     // ----------------------------------------------------------------------
 60  
     // Accessors
 61  
     // ----------------------------------------------------------------------
 62  
 
 63  
     private Multimap<String, ComponentDescriptor<?>> getComponentDescriptors( String role )
 64  
     {
 65  
         // verify arguments
 66  255906
         if ( role == null )
 67  
         {
 68  0
             throw new NullPointerException( "role is null" );
 69  
         }
 70  
 
 71  
         // determine realms to search
 72  255917
         Set<ClassRealm> realms = ClassRealmUtil.getContextRealms( null );
 73  255849
         if ( realms.isEmpty() )
 74  
         {
 75  1323
             realms.addAll( index.keySet() );
 76  
         }
 77  
 
 78  
         
 79  
         // Get all valid component descriptors
 80  255841
         Multimap<String, ComponentDescriptor<?>> roleHintIndex = LinkedHashMultimap.create();
 81  255654
         for ( ClassRealm realm : realms )
 82  
         {
 83  509850
             SortedMap<String, Multimap<String, ComponentDescriptor<?>>> roleIndex = index.get( realm );
 84  509738
             if (roleIndex != null) {
 85  509697
                 Multimap<String, ComponentDescriptor<?>> descriptors = roleIndex.get( role );
 86  503377
                 if ( descriptors != null )
 87  
                 {
 88  255653
                     roleHintIndex.putAll( descriptors );
 89  
                 }
 90  
             }
 91  509234
         }
 92  255572
         return Multimaps.unmodifiableMultimap( roleHintIndex );
 93  
     }
 94  
 
 95  
     public <T> ComponentDescriptor<T> getComponentDescriptor( Class<T> type, String role, String roleHint )
 96  
     {
 97  1307
         Multimap<String, ComponentDescriptor<?>> roleHintIndex = getComponentDescriptors( role );
 98  
 
 99  
         Collection<ComponentDescriptor<?>> descriptors;
 100  
 
 101  1307
         if ( StringUtils.isNotEmpty( roleHint ) )
 102  
         {
 103  
             // specific role hint -> get only those
 104  112
             descriptors = roleHintIndex.get( roleHint );
 105  
         }
 106  
         else
 107  
         {
 108  
             // missing role hint -> get all (wildcard)
 109  1195
             Collection<ComponentDescriptor<?>> allDescriptors = new ArrayList<ComponentDescriptor<?>>();
 110  
 
 111  1195
             descriptors = roleHintIndex.get( PlexusConstants.PLEXUS_DEFAULT_HINT );
 112  1195
             if ( descriptors != null )
 113  
             {
 114  1195
                 allDescriptors.addAll( descriptors );
 115  
             }
 116  
 
 117  1195
             for ( String hint : roleHintIndex.keySet() )
 118  
             {
 119  1160
                 descriptors = roleHintIndex.get( hint );
 120  1160
                 if ( descriptors != null )
 121  
                 {
 122  1160
                     allDescriptors.addAll( descriptors );
 123  
                 }
 124  1160
             }
 125  
 
 126  1195
             descriptors = allDescriptors;
 127  
         }
 128  
 
 129  1307
         for ( ComponentDescriptor<?> descriptor : descriptors )
 130  
         {
 131  1201
             Class<?> implClass = descriptor.getImplementationClass();
 132  1201
             if ( isAssignableFrom( type, implClass ) )
 133  
             {
 134  1181
                 return (ComponentDescriptor<T>) descriptor;
 135  
             }
 136  20
             else if ( Object.class == implClass && role.equals( type.getName() ) )
 137  
             {
 138  0
                 return (ComponentDescriptor<T>) descriptor;
 139  
             }
 140  20
         }
 141  
                 
 142  126
         return null;
 143  
     }
 144  
 
 145  
     public <T> Map<String, ComponentDescriptor<T>> getComponentDescriptorMap( Class<T> type, String role )
 146  
     {
 147  254322
         Map<String, ComponentDescriptor<T>> descriptors = new TreeMap<String, ComponentDescriptor<T>>();
 148  254515
         for ( ComponentDescriptor<?> descriptor : getComponentDescriptors( role ).values() )
 149  
         {
 150  253177
             if ( !descriptors.containsKey( descriptor.getRoleHint() ) )
 151  
             {
 152  253367
                 if ( isAssignableFrom( type, descriptor.getImplementationClass() ) )
 153  
                 {
 154  253405
                     descriptors.put( descriptor.getRoleHint(), (ComponentDescriptor<T>) descriptor );
 155  
                 }
 156  
             }
 157  252734
         }
 158  253183
         return descriptors;
 159  
     }
 160  
 
 161  
     public <T> List<ComponentDescriptor<T>> getComponentDescriptorList( Class<T> type, String role )
 162  
     {
 163  62
         List<ComponentDescriptor<T>> descriptors = new ArrayList<ComponentDescriptor<T>>();
 164  62
         for ( ComponentDescriptor<?> descriptor : getComponentDescriptors( role ).values() )
 165  
         {
 166  6
             if ( isAssignableFrom( type, descriptor.getImplementationClass() ) )
 167  
             {
 168  6
                 descriptors.add( (ComponentDescriptor<T>) descriptor );
 169  
             }
 170  6
         }
 171  62
         return descriptors;
 172  
     }
 173  
 
 174  
     @Deprecated
 175  
     public ComponentDescriptor<?> getComponentDescriptor( String role, String roleHint, ClassRealm realm )
 176  
     {
 177  
         // find all realms from our realm to the root realm
 178  0
         Set<ClassRealm> realms = new HashSet<ClassRealm>();
 179  0
         for ( ClassRealm r = realm; r != null; r = r.getParentRealm() )
 180  
         {
 181  0
             realms.add( r );
 182  
         }
 183  
 
 184  
         // get the component descriptors by roleHint
 185  0
         for ( ComponentDescriptor<?> componentDescriptor : getComponentDescriptors( role ).get( roleHint ) )
 186  
         {
 187  
             // return the first descriptor from our target realms
 188  0
             if ( realms.contains( componentDescriptor.getRealm() ) )
 189  
             {
 190  0
                 return componentDescriptor;
 191  
             }
 192  0
         }
 193  
 
 194  0
         return null;
 195  
     }
 196  
 
 197  
     public void removeComponentRealm( ClassRealm classRealm )
 198  
     {
 199  0
         index.remove( classRealm );
 200  0
     }
 201  
 
 202  
     // ----------------------------------------------------------------------
 203  
     // Lifecylce Management
 204  
     // ----------------------------------------------------------------------
 205  
 
 206  
     // ----------------------------------------------------------------------
 207  
     // Component Descriptor processing.
 208  
     // ----------------------------------------------------------------------
 209  
 
 210  
     public void addComponentDescriptor( ComponentDescriptor<?> componentDescriptor ) 
 211  
         throws CycleDetectedInComponentGraphException
 212  
     {
 213  2427
         ClassRealm classRealm = componentDescriptor.getRealm();
 214  2428
         SortedMap<String, Multimap<String, ComponentDescriptor<?>>> roleIndex = index.get( classRealm );
 215  2427
         if (roleIndex == null) {
 216  140
             roleIndex = new TreeMap<String, Multimap<String, ComponentDescriptor<?>>>();
 217  140
             index.put(classRealm,  roleIndex);
 218  
         }
 219  
 
 220  2427
         String role = componentDescriptor.getRole();
 221  2427
         Multimap<String, ComponentDescriptor<?>> roleHintIndex = roleIndex.get( role );
 222  2427
         if ( roleHintIndex == null )
 223  
         {
 224  1417
             roleHintIndex = LinkedHashMultimap.create();
 225  1417
             roleIndex.put( role, roleHintIndex );
 226  
         }
 227  2427
         roleHintIndex.put( componentDescriptor.getRoleHint(), componentDescriptor );
 228  
 
 229  2424
         compositionResolver.addComponentDescriptor( componentDescriptor );
 230  2425
     }
 231  
 }