TypeCacheImpl.java

package org.springframework.roo.classpath;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.apache.commons.lang3.Validate;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Service;
import org.springframework.roo.classpath.details.ClassOrInterfaceTypeDetails;
import org.springframework.roo.model.JavaType;
import org.springframework.roo.project.maven.Pom;

@Component
@Service
public class TypeCacheImpl implements TypeCache {

  private final Map<String, ClassOrInterfaceTypeDetails> midToTypeDetailsMap =
      new HashMap<String, ClassOrInterfaceTypeDetails>();
  private final Map<String, Set<String>> moduleFilePathToTypeNamesMap =
      new HashMap<String, Set<String>>();
  private final Map<String, Set<String>> simpleTypeNameTypesMap =
      new HashMap<String, Set<String>>();
  private final Map<String, String> typeFilePathToMidMap = new HashMap<String, String>();
  private final Map<String, String> typeIdentifierToFilePathMap = new HashMap<String, String>();
  private final Map<String, String> typeNameToMidMap = new HashMap<String, String>();
  private final Map<String, String> typeNameToModuleFilePathMap = new HashMap<String, String>();
  private final Map<String, String> typeNameToModuleNameMap = new HashMap<String, String>();
  private final Set<JavaType> types = new HashSet<JavaType>();

  public void cacheFilePathAgainstTypeIdentifier(final String typeFilePath,
      final String typeIdentifier) {
    typeFilePathToMidMap.put(typeFilePath, typeIdentifier);
  }

  public void cacheType(final String typeFilePath, final ClassOrInterfaceTypeDetails cid) {
    Validate.notBlank(typeFilePath, "Module name required");
    Validate.notNull(cid, "Type details required");

    midToTypeDetailsMap.put(cid.getDeclaredByMetadataId(), cid);
    typeFilePathToMidMap.put(typeFilePath, cid.getDeclaredByMetadataId());
    typeIdentifierToFilePathMap.put(cid.getDeclaredByMetadataId(), typeFilePath);
    types.add(cid.getName());

    final String fullyQualifiedTypeName = cid.getName().getFullyQualifiedTypeName();
    final String simpleTypeName = cid.getName().getSimpleTypeName();
    typeNameToMidMap.put(fullyQualifiedTypeName, cid.getDeclaredByMetadataId());
    if (!simpleTypeNameTypesMap.containsKey(simpleTypeName)) {
      simpleTypeNameTypesMap.put(simpleTypeName, new HashSet<String>());
    }

    simpleTypeNameTypesMap.get(simpleTypeName).add(fullyQualifiedTypeName);
  }

  public void cacheTypeAgainstModule(final Pom pom, final JavaType javaType) {
    Validate.notNull(pom, "Pom cannot be null");
    Validate.notNull(javaType, "Java type cannot be null");
    typeNameToModuleFilePathMap.put(javaType.getFullyQualifiedTypeName(), pom.getPath());
    typeNameToModuleNameMap.put(javaType.getFullyQualifiedTypeName(), pom.getModuleName());
    if (!moduleFilePathToTypeNamesMap.containsKey(pom.getPath())) {
      moduleFilePathToTypeNamesMap.put(pom.getPath(), new HashSet<String>());
    }
    moduleFilePathToTypeNamesMap.get(pom.getPath()).add(javaType.getFullyQualifiedTypeName());
  }

  public Set<String> getAllTypeIdentifiers() {
    return new HashSet<String>(midToTypeDetailsMap.keySet());
  }

  public Set<JavaType> getAllTypes() {
    return new HashSet<JavaType>(types);
  }

  public String getPhysicalTypeIdentifier(final JavaType javaType) {
    Validate.notNull(javaType, "Java type cannot be null");
    return typeNameToMidMap.get(javaType.getFullyQualifiedTypeName());
  }

  public ClassOrInterfaceTypeDetails getTypeDetails(final String mid) {
    Validate.notBlank(mid, "Physical type identifier required");
    return midToTypeDetailsMap.get(mid);
  }

  public String getTypeIdFromTypeFilePath(final String typeFilePath) {
    Validate.notBlank(typeFilePath, "Physical type file path required");
    return typeFilePathToMidMap.get(typeFilePath);
  }

  public Set<String> getTypeNamesForModuleFilePath(final String moduleFilePath) {
    Validate.notBlank(moduleFilePath, "Pom file path required");
    if (!moduleFilePathToTypeNamesMap.containsKey(moduleFilePath)) {
      moduleFilePathToTypeNamesMap.put(moduleFilePath, new HashSet<String>());
    }
    return new HashSet<String>(moduleFilePathToTypeNamesMap.get(moduleFilePath));
  }

  public Set<String> getTypesForSimpleTypeName(final String simpleTypeName) {
    if (!simpleTypeNameTypesMap.containsKey(simpleTypeName)) {
      return new HashSet<String>();
    }
    return simpleTypeNameTypesMap.get(simpleTypeName);
  }

  public void removeType(final String typeIdentifier) {
    Validate.notBlank(typeIdentifier, "Physical type identifier required");
    final ClassOrInterfaceTypeDetails cid = midToTypeDetailsMap.get(typeIdentifier);
    if (cid != null) {
      typeNameToMidMap.remove(cid.getName().getFullyQualifiedTypeName());
      typeNameToModuleFilePathMap.remove(cid.getName().getFullyQualifiedTypeName());
      typeNameToModuleNameMap.remove(cid.getName().getFullyQualifiedTypeName());
    }
    final String filePath = typeIdentifierToFilePathMap.get(typeIdentifier);
    if (filePath != null) {
      typeFilePathToMidMap.remove(filePath);
      typeIdentifierToFilePathMap.remove(typeIdentifier);
    }

  }
}