<?xml version="1.0" encoding="UTF-8"?>
<pmd version="4.3" timestamp="2012-06-09T14:25:05.877">
<file name="/Users/rgoers/projects/apache/logging/log4j/log4j2/trunk/slf4j-impl/src/main/java/org/slf4j/helpers/Log4JMDCAdapter.java">
<violation beginline="22" endline="22" begincolumn="1" endcolumn="25" rule="UnusedImports" ruleset="Import Statement Rules" package="org.slf4j.helpers" externalInfoUrl="http://pmd.sourceforge.net/rules/imports.html#UnusedImports" priority="4">
Avoid unused imports such as 'java.util.HashMap'
</violation>
</file>
<file name="/Users/rgoers/projects/apache/logging/log4j/log4j2/trunk/slf4j-impl/src/main/java/org/slf4j/impl/SLF4JLogger.java">
<violation beginline="47" endline="47" begincolumn="16" endcolumn="16" rule="UnusedLocalVariable" ruleset="Unused Code Rules" package="org.slf4j.impl" class="SLF4JLogger" variable="l" externalInfoUrl="http://pmd.sourceforge.net/rules/unusedcode.html#UnusedLocalVariable" priority="3">
Avoid unused local variables such as 'l'.
</violation>
</file>
</pmd>