sortedbugcollection.java

A static analysis tool to find bugs in Java programs

		}
	}

	private void writeBugCategories(XMLOutput xmlOutput) throws IOException {
		// Find bug categories reported
		Set<String> bugCatSet = new HashSet<String>();
		for (Iterator<BugInstance> i = iterator(); i.hasNext();) {
			BugInstance bugInstance = i.next();
			BugPattern bugPattern = bugInstance.getBugPattern();
			if (bugPattern != null) {
				bugCatSet.add(bugPattern.getCategory());
			}
		}
		// Emit element describing each reported bug code
		for (String bugCat : bugCatSet) {
			String bugCatDescription = I18N.instance().getBugCategoryDescription(bugCat);
			if (bugCatDescription == null)
				continue;

			XMLAttributeList attributeList = new XMLAttributeList();
			attributeList.addAttribute("category", bugCat);

			xmlOutput.openTag("BugCategory", attributeList);

			xmlOutput.openTag("Description");
			xmlOutput.writeText(bugCatDescription);
			xmlOutput.closeTag("Description");

			xmlOutput.closeTag("BugCategory");
		}
	}

	private void emitErrors(XMLOutput xmlOutput) throws IOException {
		//System.err.println("Writing errors to XML output");

		xmlOutput.openTag(ERRORS_ELEMENT_NAME);

		// Emit Error elements describing analysis errors
		for (Iterator<AnalysisError> i = errorIterator(); i.hasNext(); ) {
			AnalysisError error = i.next();
			xmlOutput.openTag(ERROR_ELEMENT_NAME);

			xmlOutput.openTag(ERROR_MESSAGE_ELEMENT_NAME);
			xmlOutput.writeText(error.getMessage());
			xmlOutput.closeTag(ERROR_MESSAGE_ELEMENT_NAME);

			if (error.getExceptionMessage() != null) {
				xmlOutput.openTag(ERROR_EXCEPTION_ELEMENT_NAME);
				xmlOutput.writeText(error.getExceptionMessage());
				xmlOutput.closeTag(ERROR_EXCEPTION_ELEMENT_NAME);
			}

			String stackTrace[] = error.getStackTrace();
			if (stackTrace != null) {
				for (String aStackTrace : stackTrace) {
					xmlOutput.openTag(ERROR_STACK_TRACE_ELEMENT_NAME);
					xmlOutput.writeText(aStackTrace);
					xmlOutput.closeTag(ERROR_STACK_TRACE_ELEMENT_NAME);
				}
			}

			xmlOutput.closeTag(ERROR_ELEMENT_NAME);
		}

		// Emit missing classes
		XMLOutputUtil.writeElementList(xmlOutput, MISSING_CLASS_ELEMENT_NAME,
			missingClassIterator());

		xmlOutput.closeTag(ERRORS_ELEMENT_NAME);
	}

	
	
	private void checkInputStream(InputStream in) throws IOException {
		if (in.markSupported()) {
			byte[] buf = new byte[200];
			in.mark(buf.length);

			int numRead = 0;
			while (numRead < buf.length) {
				int n = in.read(buf, numRead, buf.length - numRead);
				if (n < 0)
					throw new IOException("XML does not contain saved bug data");
				numRead += n;
			}

			in.reset();

			BufferedReader reader = new BufferedReader(Util.getReader(new ByteArrayInputStream(buf)));
			try {
			String line;
			while ((line = reader.readLine()) != null) {
				if (line.startsWith("<BugCollection"))
					return;
			}
			} finally {
				reader.close();
			}

			throw new IOException("XML does not contain saved bug data");
		}
	}

	/**
	 * Clone all of the BugInstance objects in the source Collection
	 * and add them to the destination Collection.
	 *
	 * @param dest   the destination Collection
	 * @param source the source Collection
	 */
	public static void cloneAll(Collection<BugInstance> dest, Collection<BugInstance> source) {
		for (BugInstance obj : source) {
			dest.add((BugInstance) obj.clone());
		}
	}

	public static class BugInstanceComparator implements Comparator<BugInstance> {
		private BugInstanceComparator() {}
		public int compare(BugInstance lhs, BugInstance rhs) {
			ClassAnnotation lca = lhs.getPrimaryClass();
			ClassAnnotation rca = rhs.getPrimaryClass();
			if (lca == null || rca == null)
				throw new IllegalStateException("null class annotation: " + lca + "," + rca);
			int cmp = lca.getClassName().compareTo(rca.getClassName());
			if (cmp != 0)
				return cmp;
			return lhs.compareTo(rhs);
		}
		public static final BugInstanceComparator instance = new BugInstanceComparator();
	}

	public static class MultiversionBugInstanceComparator extends BugInstanceComparator {
		@Override
		public int compare(BugInstance lhs, BugInstance rhs) {
			int result = super.compare(lhs,rhs);
			if (result != 0) return result;
			long diff  = lhs.getFirstVersion() - rhs.getFirstVersion();
			if (diff == 0)
				diff = lhs.getLastVersion() - rhs.getLastVersion();
			if (diff < 0) return -1;
			if (diff > 0) return 1;
			return 0;
		}
		public static final MultiversionBugInstanceComparator instance = new MultiversionBugInstanceComparator();
	}
	private Comparator<BugInstance> comparator;
	private TreeSet<BugInstance> bugSet;
	private List<AnalysisError> errorList;
	private TreeSet<String> missingClassSet;
	@CheckForNull private String summaryHTML;
	private ProjectStats projectStats;
//	private Map<String, ClassHash> classHashMap;
	private Map<String, ClassFeatureSet> classFeatureSetMap;
	private List<AppVersion> appVersionList;


	private boolean preciseHashOccurrenceNumbersAvailable = false;
	/**
	 * Sequence number of the most-recently analyzed version
	 * of the code.
	 */
	private long sequence;
	/**
	 * Release name of the analyzed application.
	 */
	private String releaseName;
	/**
	 * Current analysis timestamp.
	 */
	private long timestamp;

	/**
	 * Constructor.
	 * Creates an empty object.
	 */
	public SortedBugCollection() {
		this(new ProjectStats());
	}

	/**
	 * Constructor.
	 * Creates an empty object.
	 */
	public SortedBugCollection(Comparator<BugInstance> comparator) {
		this(new ProjectStats(), comparator);
	}

	/**
	 * Constructor.
	 * Creates an empty object given an existing ProjectStats.
	 * 
	 * @param projectStats the ProjectStats
	 */
	public SortedBugCollection(ProjectStats projectStats) {
		this(projectStats, MultiversionBugInstanceComparator.instance);
	}
	/**
	 * Constructor.
	 * Creates an empty object given an existing ProjectStats.
	 * 
	 * @param projectStats the ProjectStats
	 * @param comparator to use for sorting bug instances
	 */
	public SortedBugCollection(ProjectStats projectStats, Comparator<BugInstance> comparator) {
		this.projectStats = projectStats;
		this.comparator = comparator;
		bugSet = new TreeSet<BugInstance>(comparator);
		errorList = new LinkedList<AnalysisError>();
		missingClassSet = new TreeSet<String>();
		summaryHTML = null;
		classFeatureSetMap = new TreeMap<String, ClassFeatureSet>();
		sequence = 0L;
		appVersionList = new LinkedList<AppVersion>();
		releaseName = "";
		timestamp = -1L;
	}

	public boolean add(BugInstance bugInstance, boolean updateActiveTime) {
		preciseHashOccurrenceNumbersAvailable = false;
		if (updateActiveTime) {
			bugInstance.setFirstVersion(sequence);
		}

		return bugSet.add(bugInstance);
	}



	private void invalidateHashes() {
		preciseHashOccurrenceNumbersAvailable = false;
	}
	public boolean remove(BugInstance bugInstance) {
		invalidateHashes();
		return bugSet.remove(bugInstance);
	}

	public Iterator<BugInstance> iterator() {
		return bugSet.iterator();
	}

	public Collection<BugInstance> getCollection() {
		return bugSet;
	}


	public void addError(String message, Throwable exception) {
		if (exception instanceof MissingClassException) {
			MissingClassException e = (MissingClassException) exception;
			addMissingClass(AbstractBugReporter.getMissingClassName(e.getClassNotFoundException()));
			return;
		}
		if (exception instanceof ClassNotFoundException) {
			ClassNotFoundException e = (ClassNotFoundException) exception;
			addMissingClass(AbstractBugReporter.getMissingClassName(e));
			return;
		}
		errorList.add(new AnalysisError(message, exception));
	}


	public void addError(AnalysisError error) {
		errorList.add(error);
	}

	public void addMissingClass(String className) {
		if (className.startsWith("[")) {
			assert false : "Bad class name " + className;
			return;
		}
		missingClassSet.add(className);
	}

	public Iterator<AnalysisError> errorIterator() {
		return errorList.iterator();
	}

	public Iterator<String> missingClassIterator() {
		return missingClassSet.iterator();
	}

	public boolean contains(BugInstance bugInstance) {
		return bugSet.contains(bugInstance);
	}

	public BugInstance getMatching(BugInstance bugInstance) {
		SortedSet<BugInstance> tailSet = bugSet.tailSet(bugInstance);
		if (tailSet.isEmpty())
			return null;
		BugInstance first = tailSet.first();
		return bugInstance.equals(first) ? first : null;
	}

	public String getSummaryHTML() throws IOException {
		if ( summaryHTML == null ) {
			try {
				StringWriter writer = new StringWriter();
				ProjectStats stats = getProjectStats();
				stats.transformSummaryToHTML(writer);
				summaryHTML = writer.toString();
			} catch (final TransformerException e) {
				IOException ioe = new IOException("Couldn't generate summary HTML");
				ioe.initCause(e);
				throw ioe;
			}
		}

		return summaryHTML;
	}

	public ProjectStats getProjectStats() {
		return projectStats;
	}

	/* (non-Javadoc)
		 * @see edu.umd.cs.findbugs.BugCollection#lookupFromUniqueId(java.lang.String)
		 */
	@Deprecated
	public BugInstance lookupFromUniqueId(String uniqueId) {
		for(BugInstance bug : bugSet)
			if (bug.getInstanceHash().equals(uniqueId)) return bug;
		return null;
	}

		public long getSequenceNumber() {
		return sequence;
	}

	public void setSequenceNumber(long sequence) {
		this.sequence = sequence;
	}



	public SortedBugCollection duplicate() {
		SortedBugCollection dup = new SortedBugCollection((ProjectStats) projectStats.clone(), comparator);

		SortedBugCollection.cloneAll(dup.bugSet, this.bugSet);
		dup.errorList.addAll(this.errorList);
		dup.missingClassSet.addAll(this.missingClassSet);
		dup.summaryHTML = this.summaryHTML;
//		dup.classHashMap.putAll(this.classHashMap);
		dup.classFeatureSetMap.putAll(this.classFeatureSetMap);
		dup.sequence = this.sequence;
		dup.timestamp = this.timestamp;
		dup.releaseName = this.releaseName;
		for (AppVersion appVersion : appVersionList) {
			dup.appVersionList.add((AppVersion) appVersion.clone());
		}

		return dup;
	}

	/* (non-Javadoc)
	 * @see edu.umd.cs.findbugs.BugCollection#clearBugInstances()
	 */

	public void clearBugInstances() {
		bugSet.clear();
		invalidateHashes();

	}

	/* (non-Javadoc)
		 * @see edu.umd.cs.findbugs.BugCollection#getReleaseName()
		 */

	public String getReleaseName() {
		if (releaseName == null) return "";
		return releaseName;
	}

	/* (non-Javadoc)
		 * @see edu.umd.cs.findbugs.BugCollection#setReleaseName(java.lang.String)
		 */

	public void setReleaseName(String releaseName) {
		this.releaseName = releaseName;
	}

	/* (non-Javadoc)
	 * @see edu.umd.cs.findbugs.BugCollection#appVersionIterator()
	 */

	public Iterator<AppVersion> appVersionIterator() {
		return appVersionList.iterator();
	}

	/* (non-Javadoc)
	 * @see edu.umd.cs.findbugs.BugCollection#addAppVersion(edu.umd.cs.findbugs.AppVersion)
	 */

	public void addAppVersion(AppVersion appVersion) {
		appVersionList.add(appVersion);
	}

	/* (non-Javadoc)
	 * @see edu.umd.cs.findbugs.BugCollection#clearAppVersions()
	 */

	public void clearAppVersions() {
		appVersionList.clear();
	}

	/* (non-Javadoc)
	 * @see edu.umd.cs.findbugs.BugCollection#createEmptyCollectionWithMetadata()
	 */

	public SortedBugCollection createEmptyCollectionWithMetadata() {
		SortedBugCollection dup = new SortedBugCollection((ProjectStats) projectStats.clone(), comparator);	
		dup.errorList.addAll(this.errorList);
		dup.missingClassSet.addAll(this.missingClassSet);
		dup.summaryHTML = this.summaryHTML;
		dup.classFeatureSetMap.putAll(this.classFeatureSetMap);
		dup.sequence = this.sequence;
		dup.timestamp = this.timestamp;
		dup.releaseName = this.releaseName;
		for (AppVersion appVersion : appVersionList) {
			dup.appVersionList.add((AppVersion) appVersion.clone());
		}

		return dup;
	}

	/* (non-Javadoc)
	 * @see edu.umd.cs.findbugs.BugCollection#setTimestamp(long)
	 */

	public void setTimestamp(long timestamp) {
		this.timestamp = timestamp;
	}

	/* (non-Javadoc)
	 * @see edu.umd.cs.findbugs.BugCollection#getTimestamp()
	 */

	public long getTimestamp() {
		return timestamp;
	}

	/* (non-Javadoc)
	 * @see edu.umd.cs.findbugs.BugCollection#getClassFeatureSet(java.lang.String)
	 */

	public ClassFeatureSet getClassFeatureSet(String className) {
		return classFeatureSetMap.get(className);
	}

	/* (non-Javadoc)
	 * @see edu.umd.cs.findbugs.BugCollection#setClassFeatureSet(edu.umd.cs.findbugs.model.ClassFeatureSet)
	 */

	public void setClassFeatureSet(ClassFeatureSet classFeatureSet) {
		classFeatureSetMap.put(classFeatureSet.getClassName(), classFeatureSet);
	}

	/* (non-Javadoc)
	 * @see edu.umd.cs.findbugs.BugCollection#classFeatureSetIterator()
	 */

	public Iterator<ClassFeatureSet> classFeatureSetIterator() {
		return classFeatureSetMap.values().iterator();
	}

	/* (non-Javadoc)
		 * @see edu.umd.cs.findbugs.BugCollection#clearClassFeatures()
		 */
	public void clearClassFeatures() {
		classFeatureSetMap.clear();
	}

	/**
	 * @param withMessages The withMessages to set.
	 */
	public void setWithMessages(boolean withMessages) {
		this.withMessages = withMessages;
	}

	/**
	 * @return Returns the withMessages.
	 */
	public boolean getWithMessages() {
		return withMessages;
	}

	/* (non-Javadoc)
	 * @see edu.umd.cs.findbugs.BugCollection#getAppVersionFromSequenceNumber(int)
	 */
	public AppVersion getAppVersionFromSequenceNumber(long target) {
		for(AppVersion av : appVersionList)
			if (av.getSequenceNumber() == target) return av;
		if(target == this.getSequenceNumber())
			return this.getCurrentAppVersion();
		return null;
	}

	/* (non-Javadoc)
	 * @see edu.umd.cs.findbugs.BugCollection#findBug(java.lang.String, java.lang.String, int)
	 */
	public BugInstance findBug(String instanceHash, String bugType,
			int lineNumber) {
		for(BugInstance bug : bugSet) 
			if (bug.getInstanceHash().equals(instanceHash) && bug.getBugPattern().getType().equals(bugType)
					&&  bug.getPrimarySourceLineAnnotation().getStartLine() == lineNumber) return bug;
		return null;
	}

	/**
	 * @param version
	 */
	public void setAnalysisVersion(String version) {
		this.analysisVersion = version;

	}
}

// vim:ts=4