Fix CacheType outer class tangle

Fixes gh-3168

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CacheAutoConfiguration.java

@@ -131,7 +131,7 @@ public class CacheAutoConfiguration {
 			CacheType[] types = CacheType.values();
 			String[] imports = new String[types.length];
 			for (int i = 0; i < types.length; i++) {
-				imports[i] = types[i].getConfigurationClass().getName();
+				imports[i] = CacheConfigurations.getConfigurationClass(types[i]);
 			}
 			return imports;
 		}

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CacheCondition.java

@@ -40,8 +40,8 @@ class CacheCondition extends SpringBootCondition {
 		if (!resolver.containsProperty("type")) {
 			return ConditionOutcome.match("Automatic cache type");
 		}
-		CacheType cacheType = CacheType
+		CacheType cacheType = CacheConfigurations.getType(((AnnotationMetadata) metadata)
-				.forConfigurationClass(((AnnotationMetadata) metadata).getClassName());
+				.getClassName());
 		String value = resolver.getProperty("type").replace("-", "_").toUpperCase();
 		if (value.equals(cacheType.name())) {
 			return ConditionOutcome.match("Cache type " + cacheType);

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CacheConfigurations.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2012-2015 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.springframework.boot.autoconfigure.cache;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.springframework.util.Assert;
+
+/**
+ * Mappings between {@link CacheType} and {@code @Configuration}.
+ *
+ * @author Phillip Webb
+ */
+class CacheConfigurations {
+
+	private static final Map<CacheType, Class<?>> MAPPINGS;
+	static {
+		Map<CacheType, Class<?>> mappings = new HashMap<CacheType, Class<?>>();
+		mappings.put(CacheType.GENERIC, GenericCacheConfiguration.class);
+		mappings.put(CacheType.EHCACHE, EhCacheCacheConfiguration.class);
+		mappings.put(CacheType.HAZELCAST, HazelcastCacheConfiguration.class);
+		mappings.put(CacheType.INFINISPAN, InfinispanCacheConfiguration.class);
+		mappings.put(CacheType.JCACHE, JCacheCacheConfiguration.class);
+		mappings.put(CacheType.REDIS, RedisCacheConfiguration.class);
+		mappings.put(CacheType.GUAVA, GuavaCacheConfiguration.class);
+		mappings.put(CacheType.SIMPLE, SimpleCacheConfiguration.class);
+		mappings.put(CacheType.NONE, NoOpCacheConfiguration.class);
+		MAPPINGS = Collections.unmodifiableMap(mappings);
+	}
+
+	public static String getConfigurationClass(CacheType cacheType) {
+		Class<?> configurationClass = MAPPINGS.get(cacheType);
+		Assert.state(configurationClass != null, "Unknown cache type " + cacheType);
+		return configurationClass.getName();
+	}
+
+	public static CacheType getType(String configurationClassName) {
+		for (Map.Entry<CacheType, Class<?>> entry : MAPPINGS.entrySet()) {
+			if (entry.getValue().getName().equals(configurationClassName)) {
+				return entry.getKey();
+			}
+		}
+		throw new IllegalStateException("Unknown configuration class "
+				+ configurationClassName);
+	}
+
+}

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CacheType.java

@@ -29,65 +29,46 @@ public enum CacheType {
 	/**
 	 * Generic caching using 'Cache' beans from the context.
 	 */
-	GENERIC(GenericCacheConfiguration.class),
+	GENERIC,
 
 	/**
 	 * EhCache backed caching.
 	 */
-	EHCACHE(EhCacheCacheConfiguration.class),
+	EHCACHE,
 
 	/**
 	 * Hazelcast backed caching
 	 */
-	HAZELCAST(HazelcastCacheConfiguration.class),
+	HAZELCAST,
 
 	/**
 	 * Infinispan backed caching.
 	 */
-	INFINISPAN(InfinispanCacheConfiguration.class),
+	INFINISPAN,
 
 	/**
 	 * JCache (JSR-107) backed caching.
 	 */
-	JCACHE(JCacheCacheConfiguration.class),
+	JCACHE,
 
 	/**
 	 * Redis backed caching.
 	 */
-	REDIS(RedisCacheConfiguration.class),
+	REDIS,
 
 	/**
 	 * Guava backed caching.
 	 */
-	GUAVA(GuavaCacheConfiguration.class),
+	GUAVA,
 
 	/**
 	 * Simple in-memory caching.
 	 */
-	SIMPLE(SimpleCacheConfiguration.class),
+	SIMPLE,
 
 	/**
 	 * No caching.
 	 */
-	NONE(NoOpCacheConfiguration.class);
+	NONE;
-
-	private final Class<?> configurationClass;
-
-	CacheType(Class<?> configurationClass) {
-		this.configurationClass = configurationClass;
-	}
-
-	Class<?> getConfigurationClass() {
-		return this.configurationClass;
-	}
-
-	static CacheType forConfigurationClass(String configurationClass) {
-		for (CacheType type : values()) {
-			if (type.getConfigurationClass().getName().equals(configurationClass)) {
-				return type;
-			}
-		}
-		throw new IllegalArgumentException("Unsupported class " + configurationClass);
-	}
 
 }