JInterface.java

/*
 *  Copyright 2012 Chris Pheby
 *
 *  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.jadira.scanner.classpath.types;

import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import javassist.bytecode.AnnotationsAttribute;
import javassist.bytecode.ClassFile;
import javassist.bytecode.MethodInfo;
import javassist.bytecode.annotation.Annotation;

import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;
import org.jadira.scanner.classpath.ClasspathResolver;
import org.jadira.scanner.classpath.filter.JClassImplementsFilter;
import org.jadira.scanner.classpath.filter.JElementTypeFilter;
import org.jadira.scanner.classpath.filter.JTypeSubTypeOfFilter;
import org.jadira.scanner.classpath.projector.ClasspathProjector;
import org.jadira.scanner.classpath.visitor.IntrospectionVisitor;
import org.jadira.scanner.core.api.Projector;
import org.jadira.scanner.core.exception.ClasspathAccessException;

public class JInterface extends JType {

    private static final Projector<File> CLASSPATH_PROJECTOR = ClasspathProjector.SINGLETON;
    
    protected JInterface(String name, ClasspathResolver resolver) throws ClasspathAccessException {
        this(findClassFile(name, resolver), resolver);
    }

    protected JInterface(ClassFile classFile, ClasspathResolver resolver) {
        super(classFile, resolver);
        if (!classFile.isInterface() || (classFile.getSuperclass().equals("java.lang.annotation.Annotation"))) {
            throw new IllegalArgumentException("Argument was not interface: " + classFile.getName());
        }
    }
    

    public static JInterface getJInterface(String name, ClasspathResolver resolver) throws ClasspathAccessException {
        return new JInterface(name, resolver);
    }

    public static JInterface getJInterface(ClassFile classFile, ClasspathResolver resolver) {
        return new JInterface(classFile, resolver);
    }

    public List<JInterface> getSuperInterfaces() throws ClasspathAccessException {

        final List<JInterface> retVal = new ArrayList<JInterface>();
        String[] interfaces = getClassFile().getInterfaces();

        for (String next : interfaces) {
            retVal.add(JInterface.getJInterface(next, getResolver()));
        }
        return retVal;
    }
    
    public List<Class<?>> getActualSuperInterfaces() throws ClasspathAccessException {

        List<Class<?>> classes = new ArrayList<Class<?>>();
        for (JInterface next : getSuperInterfaces()) {
            classes.add(next.getActualClass());
        }
        return classes;
    }

    public List<JMethod> getMethods() {

        final List<JMethod> retVal = new ArrayList<JMethod>();
        @SuppressWarnings("unchecked")
        final List<MethodInfo> methods = (List<MethodInfo>) getClassFile().getMethods();

        for (MethodInfo next : methods) {
            if (next.isMethod()) {
                retVal.add(JMethod.getJMethod(next, this, getResolver()));
            }
        }
        return retVal;
    }

    public Class<?> getActualInterface() throws ClasspathAccessException {

        return getResolver().loadClass(getClassFile().getName());
    }

    @Override
    public Set<JAnnotation<?>> getAnnotations() throws ClasspathAccessException {

        AnnotationsAttribute visible = (AnnotationsAttribute) getClassFile().getAttribute(AnnotationsAttribute.visibleTag);
        AnnotationsAttribute invisible = (AnnotationsAttribute) getClassFile().getAttribute(AnnotationsAttribute.invisibleTag);

        Set<JAnnotation<?>> annotations = new HashSet<JAnnotation<?>>();

        List<Annotation> annotationsList = new ArrayList<Annotation>();
        if (visible != null) {
            annotationsList.addAll(Arrays.asList(visible.getAnnotations()));
        }
        if (invisible != null) {
            annotationsList.addAll(Arrays.asList(invisible.getAnnotations()));
        }

        for (Annotation nextAnnotation : annotationsList) {
            annotations.add(JAnnotation.getJAnnotation(nextAnnotation, this, getResolver()));
        }

        return annotations;
    }

    @Override
    public JPackage getPackage() throws ClasspathAccessException {

        String fqClassName = getClassFile().getName();

        String packageName;
        if (fqClassName.contains(".")) {
            packageName = fqClassName.substring(0, fqClassName.lastIndexOf('.'));
        } else {
            packageName = "";
        }

        return JPackage.getJPackage(packageName, getResolver());
    }

    @Override
    public Class<?> getActualClass() throws ClasspathAccessException {
        return getActualInterface();
    }

    public Set<JInterface> getSubInterfaces() {
        
        Set<JInterface> retVal = new HashSet<JInterface>();
        List<? extends ClassFile> classes = getResolver().getClassFileResolver().resolveAll(null, CLASSPATH_PROJECTOR, new JTypeSubTypeOfFilter(this.getActualClass()), new JElementTypeFilter(JInterface.class)); 
        for (ClassFile classFile : classes) {
            retVal.add(JInterface.getJInterface(classFile, getResolver()));
        }
        return retVal;
    }

    public Set<JClass> getImplementingClasses() {
        
        Set<JClass> retVal = new HashSet<JClass>();
        List<? extends ClassFile> classes = getResolver().getClassFileResolver().resolveAll(null, CLASSPATH_PROJECTOR, new JClassImplementsFilter(this.getActualClass()), new JElementTypeFilter(JClass.class)); 
        for (ClassFile classFile : classes) {
            retVal.add(JClass.getJClass(classFile, getResolver()));
        }
        return retVal;
    }

    @Override
    public void acceptVisitor(IntrospectionVisitor visitor) throws ClasspathAccessException {
        visitor.visit(this);

        for (JInterface next : getSuperInterfaces()) {
            next.acceptVisitor(visitor);
        }
        for (JMethod next : getMethods()) {
            next.acceptVisitor(visitor);
        }
        for (JAnnotation<?> next : getAnnotations()) {
            next.acceptVisitor(visitor);
        }
    }

    @Override
    public JPackage getEnclosingElement() {
        return getPackage();
    }
    
    @Override
	public boolean equals(Object obj) {
		if (obj == null) {
			return false;
		}
		if (obj == this) {
			return true;
		}
		if (obj.getClass() != getClass()) {
			return false;
		}
		// JInterface rhs = (JInterface) obj;
		return new EqualsBuilder()
			 	.appendSuper(super.equals(obj))
				.isEquals();
	}

    @Override
	public int hashCode() {
		return new HashCodeBuilder(11, 47).append(super.hashCode())
				.toHashCode();
	}
}