/*
* FindBugs - Find bugs in Java programs
* Copyright (C) 2003,2004 University of Maryland
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package edu.umd.cs.findbugs;
import edu.umd.cs.findbugs.ba.AnalysisContext;
import edu.umd.cs.findbugs.classfile.ClassDescriptor;
import edu.umd.cs.findbugs.classfile.DescriptorFactory;
import edu.umd.cs.findbugs.internalAnnotations.DottedClassName;
import edu.umd.cs.findbugs.internalAnnotations.SlashedClassName;
import edu.umd.cs.findbugs.util.ClassName;
/**
* Abstract base class for BugAnnotations describing constructs which are
* contained in a Java package. Specifically, this includes classes, methods,
* and fields.
*
* @author David Hovemeyer
* @see BugAnnotation
*/
public abstract class PackageMemberAnnotation extends BugAnnotationWithSourceLines {
private static final long serialVersionUID = -8208567669352996892L;
protected final @DottedClassName
String className;
protected String description;
/**
* Constructor.
*
* @param className
* name of the class
*/
protected PackageMemberAnnotation(@DottedClassName String className, String description) {
this(className, description, computeSourceFile(className));
}
private static String computeSourceFile(String className) {
AnalysisContext context = AnalysisContext.currentAnalysisContext();
if (context != null)
return context.lookupSourceFile(className);
return SourceLineAnnotation.UNKNOWN_SOURCE_FILE;
}
/**
* Constructor.
*
* @param className
* name of the class
*/
protected PackageMemberAnnotation(@DottedClassName String className, String description, String sourceFileName) {
if (className.length() == 0)
throw new IllegalArgumentException("Empty classname not allowed");
if (className.indexOf('/') >= 0) {
assert false : "classname " + className + " should be dotted";
className = className.replace('/', '.');
}
this.className = DescriptorFactory.canonicalizeString(className);
this.sourceFileName = sourceFileName;
if (description != null)
description = description.intern();
this.description = description;
}
/**
* Get the dotted class name.
*/
public final @DottedClassName
String getClassName() {
return className;
}
/**
* Get the dotted class name.
*/
public final @SlashedClassName
String getSlashedClassName() {
return ClassName.toSlashedClassName(className);
}
public String getSimpleClassName() {
return ClassName.extractSimpleName(className);
}
/**
* Get the class descriptor.
*/
public final ClassDescriptor getClassDescriptor() {
return DescriptorFactory.instance().getClassDescriptorForDottedClassName(className);
}
/**
* Get the package name.
*/
public final @DottedClassName
String getPackageName() {
int lastDot = className.lastIndexOf('.');
if (lastDot < 0)
return "";
else
return className.substring(0, lastDot);
}
/**
* Format the annotation. Note that this version (defined by
* PackageMemberAnnotation) only handles the "class" and "package" keys, and
* calls formatPackageMember() for all other keys.
*
* @param key
* the key
* @return the formatted annotation
*/
public final String format(String key, ClassAnnotation primaryClass) {
if (key.equals("class.givenClass"))
return shorten(primaryClass.getPackageName(), className);
if (key.equals("simpleClass"))
return ClassName.extractSimpleName(className);
if (key.equals("class"))
return className;
if (key.equals("package"))
return getPackageName();
if (key.equals("") && FindBugsDisplayFeatures.isAbridgedMessages() && primaryClass != null)
return formatPackageMember("givenClass", primaryClass);
return formatPackageMember(key, primaryClass);
}
public void setDescription(String description) {
this.description = description.intern();
}
public String getDescription() {
return description;
}
/**
* Shorten a type name of remove extraneous components. Candidates for
* shortening are classes in same package as this annotation and classes in
* the <code>java.lang</code> package.
*/
protected static String shorten(String pkgName, String typeName) {
int index = typeName.lastIndexOf('.');
if (index >= 0) {
String otherPkg = typeName.substring(0, index);
if (otherPkg.equals(pkgName) || otherPkg.equals("java.lang"))
typeName = typeName.substring(index + 1);
}
return typeName;
}
protected static String removePackage(String typeName) {
int index = typeName.lastIndexOf('.');
if (index >= 0) {
return typeName.substring(index + 1);
}
return typeName;
}
/**
* Shorten a type name by removing the package name
*/
protected static String removePackageName(String typeName) {
int index = typeName.lastIndexOf('.');
if (index >= 0) {
typeName = typeName.substring(index + 1);
}
return typeName;
}
/**
* Do default and subclass-specific formatting.
*
* @param key
* the key specifying how to do the formatting
* @param primaryClass
* TODO
*/
protected abstract String formatPackageMember(String key, ClassAnnotation primaryClass);
/**
* All PackageMemberAnnotation object share a common toString()
* implementation. It uses the annotation description as a pattern for
* FindBugsMessageFormat, passing a reference to this object as the single
* message parameter.
*/
@Override
public String toString() {
return toString(null);
}
@Override
public String toString(ClassAnnotation primaryClass) {
String pattern = I18N.instance().getAnnotationDescription(description);
FindBugsMessageFormat format = new FindBugsMessageFormat(pattern);
return format.format(new BugAnnotation[] { this }, primaryClass);
}
public boolean isSignificant() {
return true;
}
}
// vim:ts=4