org.cruxframework.crux.scanner.ClassScanner.java Source code

Introduction

Here is the source code for org.cruxframework.crux.scanner.ClassScanner.java

Source

/*
 * Copyright 2011 cruxframework.org.
 * 
 * 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.cruxframework.crux.scanner;

import java.lang.annotation.Annotation;
import java.util.HashSet;
import java.util.Set;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * @author Thiago da Rosa de Bustamante
 *
 */
public class ClassScanner {
    private static final Log logger = LogFactory.getLog(ClassScanner.class);

    private static AnnotationDB scannerDB = new AnnotationDB();
    private static boolean initialized = false;
    private static boolean scannerInitialized = false;

    /**
     * 
     */
    private ClassScanner() {
    }

    /**
     * 
     * @param urls
     */
    public synchronized static void initialize() {
        if (!isInitialized()) {
            if (!scannerInitialized) {
                initializeScanner();
            }
            buildIndex();
            setInitialized();
        }
    }

    static void setInitialized() {
        initialized = true;
    }

    public static void reset() {
        initialized = false;
    }

    public static void initializeScanner() {
        if (!scannerInitialized) {
            Scanners.registerScanner(scannerDB);
            scannerDB.setScanFieldAnnotations(false);
            scannerDB.setScanMethodAnnotations(false);
            scannerDB.setScanParameterAnnotations(false);
            scannerInitialized = true;
        }
    }

    /**
     * 
     * @param urls
     * @throws ClassScannerException
     */
    private static void buildIndex() throws ClassScannerException {
        try {
            if (logger.isInfoEnabled()) {
                logger.info("Building index of annotations for classes.");
            }

            scannerDB.scanArchives();
        } catch (Exception e) {
            throw new ClassScannerException("Error creating index of annotations.", e);
        }
    }

    /**
     * Search into the internal index for the set of classes that contains the given annotation.
     * @param annotationClass
     * @return
     */
    public static Set<String> searchClassesByAnnotation(Class<? extends Annotation> annotationClass) {
        if (!isInitialized()) {
            initialize();
        }
        return scannerDB.getAnnotationIndex().get(annotationClass.getName());
    }

    /**
     * Search into the internal index for the set of classes that implements the given interface.
     * @param annotationClass
     * @return
     */
    public static Set<String> searchClassesByInterface(Class<?> interfaceClass) {
        if (!interfaceClass.isInterface()) {
            throw new ClassScannerException("The class [" + interfaceClass.getName() + "] is not an interface.");
        }
        return searchClassesByInterface(interfaceClass.getName(), true);
    }

    /**
     * 
     * @param className
     * @param deep
     * @return
     */
    public static Set<String> searchClassesByInterface(String className, boolean deep) {
        if (!isInitialized()) {
            initialize();
        }
        Set<String> result = new HashSet<String>();
        Set<String> classes = scannerDB.getInterfacesIndex().get(className);

        if (classes != null && classes.size() > 0) {
            result.addAll(classes);
            if (deep) {
                for (String c : classes) {
                    Set<String> deepInterfaces = searchClassesByInterface(c, deep);
                    if (deepInterfaces != null) {
                        result.addAll(deepInterfaces);
                    }
                }
            }
        }
        return result;
    }

    /**
     * return true if the scanner was already loaded.
     * @return
     */
    public static boolean isInitialized() {
        return initialized;
    }
}