ClassFinder.java

/*
 * Class:        ClassFinder
 * Description:  Convert a simple class name to a fully qualified class object
 * Environment:  Java
 * Software:     SSJ 
 * Copyright (C) 2001  Pierre L'Ecuyer and Universite de Montreal
 * Organization: DIRO, Universite de Montreal
 * @author       
 * @since
 *
 *
 * 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 umontreal.ssj.util;
 
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class ClassFinder implements Cloneable, java.io.Serializable {
   private static final long serialVersionUID = -4847630831331065792L;

   private List<List<String>> imports = new LinkedList<List<String>>();

   public ClassFinder() {
      List<String> imp = new ArrayList<String>();
      imports.add(imp);
   }

   public List<String> getImports() {
      return imports.get(imports.size() - 1);
   }

   public void saveImports() {
      List<String> imp = getImports();
      List<String> impBack = new ArrayList<String>(imp);
      imports.add(impBack);
   }

   public void restoreImports() {
      if (imports.size() == 1)
         getImports().clear();
      else
         imports.remove(imports.size() - 1);
   }

   public Class<?> findClass(String name) throws ClassNotFoundException, NameConflictException {
      // Try to consider the name as a fully qualified class name
      try {
         return Class.forName(name);
      } catch (ClassNotFoundException cnfe) {
      }
 
      List<String> imports = getImports();
      Class<?> candidate = null;
      String candidateImportString = "";
      boolean candidateImportOnDemand = false;
 
      // Determines the name of the outermost class
      // if name corresponds to the simple name of a nested class, e.g., for A.B.C
      // outerName will contain A.
      int idxOut = name.indexOf('.');
      String outerName;
      if (idxOut == -1)
         outerName = name;
      else
         outerName = name.substring(0, idxOut);
      for (String importString : imports) {
         // For each import declaration, we try to load
         // a class and store the result in cl.
         // When cl is not null, the Class object is
         // compared with the best candidate candidate.
         Class<?> cl = null;
         boolean onDemand = false;
         if (!importString.endsWith(".*")) {
            // Single-type import declaration
            // We must ensure that this will correspond to
            // the desired class name. For example, if we
            // search List and the import java.util.ArrayList
            // is found in importString, the ArrayList
            // class must not be returned.
            if (importString.endsWith("." + outerName)) {
               // The name of outer class was found in importString and
               // a period is found left to it.
               // So try to load this class.
               // Simple class names have precedence over
               // on-demand names.
 
               // Replace, in importString, the name of
               // the outer class with the true class name
               // we want to load. If the simple name
               // does not refer to a nested class, this
               // has no effect.
               String cn = importString.substring(0, importString.length() - outerName.length()) + name;
               try {
                  cl = Class.forName(cn);
               } catch (ClassNotFoundException cnfe) {
               }
            }
         } else {
            // Type import on demand declaration
            try {
               // Replace the * with name and
               // try to load the class.
               // If that succeeds, our candidate cl
               // is onDemand.
               cl = Class.forName(importString.substring(0, importString.length() - 1) + name);
               onDemand = true;
            } catch (ClassNotFoundException cnfe) {
            }
         }
         if (cl != null) {
            // Something was loaded
            if (candidate == null || (candidateImportOnDemand && !onDemand)) {
               // We had no candidate or the candidate was imported
               // on-demand while this one is a single-type import.
               candidate = cl;
               candidateImportString = importString;
               candidateImportOnDemand = onDemand;
            } else if (candidate != cl)
               throw new NameConflictException(this, name,
                     "simple class name " + name + " matches " + candidate.getName() + " (import string "
                           + candidateImportString + ") or " + cl.getName() + " (import string " + importString + ")");
         }
      }
      if (candidate == null)
         throw new ClassNotFoundException("Cannot find the class with name " + name);
      return candidate;
   }

   public String getSimpleName(Class<?> cls) {
      if (cls.isArray())
         return getSimpleName(cls.getComponentType()) + "[]";
      if (cls.isPrimitive())
         return cls.getName();
      Class<?> outer = cls;
      while (outer.getDeclaringClass() != null)
         outer = outer.getDeclaringClass();
      boolean needsFullyQualified = true;
      for (String importString : getImports()) {
         if (importString.equals(outer.getName()))
            // A single-type import is given, can return an unqualified name.
            needsFullyQualified = false;
         else if (importString.endsWith(".*")) {
            // Remove the .* at the end of the import string to get a package name.
            String pack = importString.substring(0, importString.length() - 2);
            // Compare this package name.
            if (pack.equals(cls.getPackage().getName()))
               needsFullyQualified = false;
         }
      }
      if (needsFullyQualified)
         return cls.getName();
      else {
         String name = cls.getName();
         String pack = cls.getPackage().getName();
         if (!name.startsWith(pack))
            throw new IllegalStateException("The class name " + name + " does not contain the package name " + pack);
 
         // Removes the package and the . from the fully qualified class name.
         return name.substring(pack.length() + 1);
      }
   }

   public ClassFinder clone() {
      ClassFinder cf;
      try {
         cf = (ClassFinder) super.clone();
      } catch (CloneNotSupportedException cne) {
         throw new InternalError("CloneNotSupported thrown for a class implementing Cloneable");
      }
      cf.imports = new LinkedList<List<String>>();
      for (List<String> imp : imports) {
         List<String> impCpy = new ArrayList<String>(imp);
         cf.imports.add(impCpy);
      }
      return cf;
   }
}