diff --git a/resolver/src/main/java/org/apache/felix/resolver/Candidates.java b/resolver/src/main/java/org/apache/felix/resolver/Candidates.java
index 6b946df..3e57f6e 100644
--- a/resolver/src/main/java/org/apache/felix/resolver/Candidates.java
+++ b/resolver/src/main/java/org/apache/felix/resolver/Candidates.java
@@ -444,7 +444,7 @@
             Requirement substitutedReq = m_subtitutableMap.get(substituteStatus.getKey());
             if (substitutedReq != null)
             {
-                ResolverImpl.permutateIfNeeded(this, substitutedReq, importPermutations);
+                permutateIfNeeded(substitutedReq, importPermutations);
             }
             Set<Requirement> dependents = m_dependentMap.get(substituteStatus.getKey());
             if (dependents != null)
@@ -480,7 +480,7 @@
                         {
                             if (Util.isOptional(dependent))
                             {
-                                clearCandidates(dependent);
+                                m_candidateMap.remove(dependent);
                             }
                             else
                             {
@@ -781,12 +781,35 @@
      */
     public List<Capability> getCandidates(Requirement req)
     {
-        return m_candidateMap.get(req);
+        return Collections.unmodifiableList(m_candidateMap.get(req));
     }
 
-    public void clearCandidates(Requirement req)
+    public Capability getFirstCandidate(Requirement req)
     {
-        m_candidateMap.remove(req);
+        List<Capability> candidates = m_candidateMap.get(req);
+        if (candidates != null && !candidates.isEmpty())
+        {
+            return m_candidateMap.get(req).get(0);
+        }
+        return null;
+    }
+
+    public void removeFirstCandidate(Requirement req)
+    {
+        List<Capability> candidates = m_candidateMap.get(req);
+        // Remove the conflicting candidate.
+        candidates.remove(0);
+        if (candidates.isEmpty())
+        {
+            m_candidateMap.remove(req);
+        }
+    }
+
+    public List<Capability> clearCandidates(Requirement req, Collection<Capability> caps)
+    {
+        List<Capability> l = m_candidateMap.get(req);
+        l.removeAll(caps);
+        return l;
     }
 
     /**
@@ -1260,4 +1283,50 @@
         }
         System.out.println("=== END CANDIDATE MAP ===");
     }
+
+    public void permutate(Requirement req, List<Candidates> permutations)
+    {
+        if (!Util.isMultiple(req) && canRemoveCandidate(req))
+        {
+            Candidates perm = copy();
+            perm.removeFirstCandidate(req);
+            permutations.add(perm);
+        }
+    }
+
+    public boolean canRemoveCandidate(Requirement req)
+    {
+        List<Capability> candidates = m_candidateMap.get(req);
+        return ((candidates != null) && (candidates.size() > 1 || Util.isOptional(req)));
+    }
+
+    public void permutateIfNeeded(Requirement req, List<Candidates> permutations)
+    {
+        List<Capability> candidates = m_candidateMap.get(req);
+        if ((candidates != null) && (candidates.size() > 1))
+        {
+            // Check existing permutations to make sure we haven't
+            // already permutated this requirement. This check for
+            // duplicate permutations is simplistic. It assumes if
+            // there is any permutation that contains a different
+            // initial candidate for the requirement in question,
+            // then it has already been permutated.
+            boolean permutated = false;
+            for (Candidates existingPerm : permutations)
+            {
+                List<Capability> existingPermCands = existingPerm.m_candidateMap.get(req);
+                if (existingPermCands != null && !existingPermCands.get(0).equals(candidates.get(0)))
+                {
+                    permutated = true;
+                }
+            }
+            // If we haven't already permutated the existing
+            // import, do so now.
+            if (!permutated)
+            {
+                permutate(req, permutations);
+            }
+        }
+    }
+
 }
diff --git a/resolver/src/main/java/org/apache/felix/resolver/ResolverImpl.java b/resolver/src/main/java/org/apache/felix/resolver/ResolverImpl.java
index 230912a..720aadb 100644
--- a/resolver/src/main/java/org/apache/felix/resolver/ResolverImpl.java
+++ b/resolver/src/main/java/org/apache/felix/resolver/ResolverImpl.java
@@ -244,8 +244,7 @@
                         List<Requirement> hostReq = hostReqs.get(resource);
                         if (hostReq != null)
                         {
-                            target = allCandidates.getCandidates(hostReq.get(0))
-                                .iterator().next().getResource();
+                            target = allCandidates.getFirstCandidate(hostReq.get(0)).getResource();
                         }
 
                         calculatePackageSpaces(
@@ -351,8 +350,7 @@
                         List<Requirement> hostReq = hostReqs.get(resource);
                         if (hostReq != null)
                         {
-                            target = allCandidates.getCandidates(hostReq.get(0))
-                                .iterator().next().getResource();
+                            target = allCandidates.getFirstCandidate(hostReq.get(0)).getResource();
                         }
 
                         if (allCandidates.isPopulated(target))
@@ -908,17 +906,19 @@
                             req.getDirectives()
                             .get(BundleNamespace.REQUIREMENT_VISIBILITY_DIRECTIVE);
                         if ((value != null)
-                            && value.equals(BundleNamespace.VISIBILITY_REEXPORT)
-                            && (allCandidates.getCandidates(req) != null))
+                            && value.equals(BundleNamespace.VISIBILITY_REEXPORT))
                         {
-                            mergeCandidatePackages(
-                                rc,
-                                current,
-                                currentReq,
-                                allCandidates.getCandidates(req).iterator().next(),
-                                resourcePkgMap,
-                                allCandidates,
-                                cycles);
+                            Capability cap = allCandidates.getFirstCandidate(req);
+                            if (cap != null) {
+                                mergeCandidatePackages(
+                                        rc,
+                                        current,
+                                        currentReq,
+                                        cap,
+                                        resourcePkgMap,
+                                        allCandidates,
+                                        cycles);
+                            }
                         }
                     }
                 }
@@ -1150,9 +1150,9 @@
                     else if (!sourceBlame.m_cap.getResource().equals(blame.m_cap.getResource()))
                     {
                         // Try to permutate the conflicting requirement.
-                        permutate(allCandidates, blame.m_reqs.get(0), importPermutations);
+                        allCandidates.permutate(blame.m_reqs.get(0), importPermutations);
                         // Try to permutate the source requirement.
-                        permutate(allCandidates, sourceBlame.m_reqs.get(0), importPermutations);
+                        allCandidates.permutate(sourceBlame.m_reqs.get(0), importPermutations);
                         // Report conflict.
                         ResolutionException ex = new ResolutionException(
                             "Uses constraint violation. Unable to resolve resource "
@@ -1248,17 +1248,9 @@
                             // See if we can permutate the candidates for blamed
                             // requirement; there may be no candidates if the resource
                             // associated with the requirement is already resolved.
-                            List<Capability> candidates = permutation.getCandidates(req);
-                            if ((candidates != null) && (candidates.size() > 1 || Util.isOptional(req)))
-                            {
+                            if (permutation.canRemoveCandidate(req)) {
+                                permutation.removeFirstCandidate(req);
                                 mutated.add(req);
-                                // Remove the conflicting candidate.
-                                candidates.remove(0);
-                                if (candidates.isEmpty())
-                                {
-                                    permutation.clearCandidates(req);
-                                }
-                                // Continue with the next uses constraint.
                                 break;
                             }
                         }
@@ -1361,17 +1353,9 @@
                             // See if we can permutate the candidates for blamed
                             // requirement; there may be no candidates if the resource
                             // associated with the requirement is already resolved.
-                            List<Capability> candidates = permutation.getCandidates(req);
-                            if ((candidates != null) && (candidates.size() > 1 || Util.isOptional(req)))
-                            {
+                            if (permutation.canRemoveCandidate(req)) {
+                                permutation.removeFirstCandidate(req);
                                 mutated.add(req);
-                                // Remove the conflicting candidate.
-                                candidates.remove(0);
-                                if (candidates.isEmpty())
-                                {
-                                    permutation.clearCandidates(req);
-                                }
-                                // Continue with the next uses constraint.
                                 break;
                             }
                         }
@@ -1404,7 +1388,7 @@
                             // with existing import decisions, we may end up trying
                             // to permutate the same import a lot of times, so we should
                             // try to check if that the case and only permutate it once.
-                            permutateIfNeeded(allCandidates, req, importPermutations);
+                            allCandidates.permutateIfNeeded(req, importPermutations);
                         }
                     }
 
@@ -1427,10 +1411,9 @@
         int permCount = usesPermutations.size() + importPermutations.size();
         for (Requirement req : resource.getRequirements(null))
         {
-            List<Capability> cands = allCandidates.getCandidates(req);
-            if (cands != null && !cands.isEmpty())
+            Capability cap = allCandidates.getFirstCandidate(req);
+            if (cap != null)
             {
-                Capability cap = cands.get(0);
                 if (!resource.equals(cap.getResource()))
                 {
                     try
@@ -1447,7 +1430,7 @@
                         // to backtrack on our current candidate selection.
                         if (permCount == (usesPermutations.size() + importPermutations.size()))
                         {
-                            permutate(allCandidates, req, importPermutations);
+                            allCandidates.permutate(req, importPermutations);
                         }
                         throw ex;
                     }
@@ -1476,64 +1459,13 @@
             }
             // Get the current candidate list and remove all the offending root
             // cause candidates from a copy of the current permutation.
-            candidates = session.getMultipleCardCandidates().getCandidates(req);
-            candidates.removeAll(usedBlames.getRootCauses(req));
+            candidates = session.getMultipleCardCandidates().clearCandidates(req, usedBlames.getRootCauses(req));
         }
         // We only are successful if there is at least one candidate left
         // for the requirement
         return (candidates != null) && !candidates.isEmpty();
     }
 
-    private static void permutate(
-        Candidates allCandidates, Requirement req, List<Candidates> permutations)
-    {
-        if (!Util.isMultiple(req))
-        {
-            List<Capability> candidates = allCandidates.getCandidates(req);
-            if ((candidates != null) && (candidates.size() > 1 || Util.isOptional(req)))
-            {
-                Candidates perm = allCandidates.copy();
-                candidates = perm.getCandidates(req);
-                candidates.remove(0);
-                if (candidates.isEmpty())
-                {
-                    perm.clearCandidates(req);
-                }
-                permutations.add(perm);
-            }
-        }
-    }
-
-    static void permutateIfNeeded(
-        Candidates allCandidates, Requirement req, List<Candidates> permutations)
-    {
-        List<Capability> candidates = allCandidates.getCandidates(req);
-        if ((candidates != null) && (candidates.size() > 1))
-        {
-            // Check existing permutations to make sure we haven't
-            // already permutated this requirement. This check for
-            // duplicate permutations is simplistic. It assumes if
-            // there is any permutation that contains a different
-            // initial candidate for the requirement in question,
-            // then it has already been permutated.
-            boolean permutated = false;
-            for (Candidates existingPerm : permutations)
-            {
-                List<Capability> existingPermCands = existingPerm.getCandidates(req);
-                if (existingPermCands != null && !existingPermCands.get(0).equals(candidates.get(0)))
-                {
-                    permutated = true;
-                }
-            }
-            // If we haven't already permutated the existing
-            // import, do so now.
-            if (!permutated)
-            {
-                permutate(allCandidates, req, permutations);
-            }
-        }
-    }
-
     private static void calculateExportedPackages(
         ResolveContext rc,
         Resource resource,
@@ -1579,11 +1511,10 @@
                 {
                     if (req.getNamespace().equals(PackageNamespace.PACKAGE_NAMESPACE))
                     {
-                        List<Capability> cands = allCandidates.getCandidates(req);
-                        if ((cands != null) && !cands.isEmpty())
+                        Capability cand = allCandidates.getFirstCandidate(req);
+                        if (cand != null)
                         {
-                            String pkgName = (String) cands.get(0)
-                                .getAttributes().get(PackageNamespace.PACKAGE_NAMESPACE);
+                            String pkgName = (String) cand.getAttributes().get(PackageNamespace.PACKAGE_NAMESPACE);
                             exports.remove(pkgName);
                         }
                     }
@@ -1804,9 +1735,9 @@
                                 if (IdentityNamespace.IDENTITY_NAMESPACE.equals(cand.getNamespace())
                                     && Util.isFragment(targetCand))
                                 {
-                                    targetCand = allCandidates.getCandidates(
-                                        targetCand.getRequirements(HostNamespace.HOST_NAMESPACE).get(0))
-                                        .iterator().next().getResource();
+                                    targetCand = allCandidates.getFirstCandidate(
+                                            targetCand.getRequirements(HostNamespace.HOST_NAMESPACE).get(0))
+                                        .getResource();
                                     targetCand = allCandidates.getWrappedHost(targetCand);
                                 }
 
@@ -1908,12 +1839,10 @@
 
     private static Wire createWire(Requirement requirement, Candidates allCandidates)
     {
-        List<Capability> candidates = allCandidates.getCandidates(requirement);
-        if (candidates == null || candidates.isEmpty())
-        {
+        Capability cand = allCandidates.getFirstCandidate(requirement);
+        if (cand == null) {
             return null;
         }
-        Capability cand = candidates.get(0);
         return new WireImpl(
             getDeclaredResource(requirement.getResource()),
             getDeclaredRequirement(requirement),
@@ -1946,9 +1875,8 @@
         List<Wire> packageWires = new ArrayList<Wire>();
 
         // Get the candidates for the current dynamic requirement.
-        List<Capability> candCaps = allCandidates.getCandidates(dynReq);
         // Record the dynamic candidate.
-        Capability dynCand = candCaps.get(0);
+        Capability dynCand = allCandidates.getFirstCandidate(dynReq);
 
         if (!rc.getWirings().containsKey(dynCand.getResource()))
         {
@@ -2117,18 +2045,12 @@
     private static Capability getSatisfyingCapability(
         ResolveContext rc, Candidates allCandidates, Requirement req)
     {
-        Capability cap = null;
-
         // If the requiring revision is not resolved, then check in the
         // candidate map for its matching candidate.
-        List<Capability> cands = allCandidates.getCandidates(req);
-        if (cands != null)
-        {
-            cap = cands.get(0);
-        }
+        Capability cap = allCandidates.getFirstCandidate(req);
         // Otherwise, if the requiring revision is resolved then check
         // in its wires for the capability satisfying the requirement.
-        else if (rc.getWirings().containsKey(req.getResource()))
+        if (cap == null && rc.getWirings().containsKey(req.getResource()))
         {
             List<Wire> wires =
                 rc.getWirings().get(req.getResource()).getRequiredResourceWires(null);