/*
* Copyright 2010 Henry Coles
*
* 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.pitest.classinfo;
import java.lang.annotation.Annotation;
import java.math.BigInteger;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import org.objectweb.asm.Opcodes;
import org.pitest.functional.F;
import org.pitest.functional.FCollection;
import org.pitest.functional.Option;
public class ClassInfo {
private final ClassIdentifier id;
private final int access;
private final Set<Integer> codeLines;
private final ClassPointer outerClass;
private final ClassPointer superClass;
private final Collection<ClassName> annotations;
private final String sourceFile;
private final Map<ClassName, Object> classAnnotationValues;
public ClassInfo(final ClassPointer superClass,
final ClassPointer outerClass, final ClassInfoBuilder builder) {
this.superClass = superClass;
this.outerClass = outerClass;
this.id = builder.id;
this.access = builder.access;
this.codeLines = builder.codeLines;
this.annotations = FCollection.map(builder.annotations,
ClassName.stringToClassName());
this.sourceFile = builder.sourceFile;
this.classAnnotationValues = builder.classAnnotationValues;
}
public int getNumberOfCodeLines() {
return this.codeLines.size();
}
public boolean isCodeLine(final int line) {
return this.codeLines.contains(line);
}
public ClassIdentifier getId() {
return this.id;
}
public ClassName getName() {
return this.id.getName();
}
public boolean isInterface() {
return (this.access & Opcodes.ACC_INTERFACE) != 0;
}
public boolean isAbstract() {
return (this.access & Opcodes.ACC_ABSTRACT) != 0;
}
public boolean isSynthetic() {
return (this.access & Opcodes.ACC_SYNTHETIC) != 0;
}
public boolean isTopLevelClass() {
return getOuterClass().hasNone();
}
public Option<ClassInfo> getOuterClass() {
return this.outerClass.fetch();
}
public Option<ClassInfo> getSuperClass() {
return getParent();
}
public String getSourceFileName() {
return this.sourceFile;
}
public boolean hasAnnotation(final Class<? extends Annotation> annotation) {
return hasAnnotation(new ClassName(annotation));
}
public boolean hasAnnotation(final ClassName annotation) {
return this.annotations.contains(annotation);
}
public Object getClassAnnotationValue(final ClassName annotation) {
return this.classAnnotationValues.get(annotation);
}
public boolean descendsFrom(final Class<?> clazz) {
return descendsFrom(new ClassName(clazz.getName()));
}
public HierarchicalClassId getHierarchicalId() {
return new HierarchicalClassId(this.id, getDeepHash());
}
public BigInteger getDeepHash() {
BigInteger hash = getHash();
final Option<ClassInfo> parent = getParent();
if (parent.hasSome()) {
hash = hash.add(parent.value().getHash());
}
final Option<ClassInfo> outer = getOuterClass();
if (outer.hasSome()) {
hash = hash.add(outer.value().getHash());
}
return hash;
}
public BigInteger getHash() {
return BigInteger.valueOf(this.id.getHash());
}
private Option<ClassInfo> getParent() {
if (this.superClass == null) {
return Option.none();
}
return this.superClass.fetch();
}
private boolean descendsFrom(final ClassName clazz) {
if (this.getSuperClass().hasNone()) {
return false;
}
if (this.getSuperClass().value().getName().equals(clazz)) {
return true;
}
return getSuperClass().value().descendsFrom(clazz);
}
public static F<ClassInfo, Boolean> matchIfAbstract() {
return new F<ClassInfo, Boolean>() {
@Override
public Boolean apply(final ClassInfo a) {
return a.isAbstract();
}
};
}
@Override
public String toString() {
return this.id.getName().asJavaName();
}
public static F<ClassInfo, ClassName> toClassName() {
return new F<ClassInfo, ClassName>() {
@Override
public ClassName apply(final ClassInfo a) {
return a.getName();
}
};
}
public static F<ClassInfo, HierarchicalClassId> toFullClassId() {
return new F<ClassInfo, HierarchicalClassId>() {
@Override
public HierarchicalClassId apply(final ClassInfo a) {
return a.getHierarchicalId();
}
};
}
}