<!DOCTYPE html>
<!--
 | Generated by Apache Maven Doxia Site Renderer 1.9.2 from org.apache.maven.plugins:maven-pmd-plugin:3.14.0:pmd at 21 September 2021
 | Rendered using Apache Maven Fluido Skin 1.9
-->
<html xmlns="http://www.w3.org/1999/xhtml" lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <meta name="generator" content="Apache Maven Doxia Site Renderer 1.9.2" />
    <title>Fulcrum Factory &#x2013; PMD Results</title>
    <link rel="stylesheet" href="./css/apache-maven-fluido-1.9.min.css" />
    <link rel="stylesheet" href="./css/site.css" />
    <link rel="stylesheet" href="./css/print.css" media="print" />
    <script src="./js/apache-maven-fluido-1.9.min.js"></script>
  </head>
  <body class="topBarDisabled">
    <div class="container-fluid">
      <header>
        <div id="banner">
          <div class="pull-left"><a href="https://turbine.apache.org/" id="bannerLeft" title="Apache Turbine"><img src="https://turbine.apache.org/images/turbine-project.png"  alt="Apache Turbine"/></a></div>
          <div class="pull-right"></div>
          <div class="clear"><hr/></div>
        </div>

        <div id="breadcrumbs">
          <ul class="breadcrumb">
        <li id="publishDate">Last Published: 21 September 2021<span class="divider">|</span>
</li>
          <li id="projectVersion">Version: 1.1.2-SNAPSHOT</li>
      <li class="pull-right"><span class="divider">|</span>
<a href="https://turbine.apache.org/fulcrum/" class="externalLink" title="Fulcrum">Fulcrum</a></li>
      <li class="pull-right"><span class="divider">|</span>
<a href="https://turbine.apache.org/" class="externalLink" title="Turbine">Turbine</a></li>
      <li class="pull-right"><a href="https://www.apache.org" class="externalLink" title="Apache">Apache</a></li>
          </ul>
        </div>
      </header>
      <div class="row-fluid">
        <header id="leftColumn" class="span2">
          <nav class="well sidebar-nav">
  <ul class="nav nav-list">
   <li class="nav-header">Overview</li>
    <li><a href="index.html" title="Main"><span class="none"></span>Main</a></li>
    <li><a href="tasks.html" title="ToDos"><span class="none"></span>ToDos</a></li>
   <li class="nav-header">Project Documentation</li>
    <li><a href="project-info.html" title="Project Information"><span class="icon-chevron-right"></span>Project Information</a></li>
    <li><a href="project-reports.html" title="Project Reports"><span class="icon-chevron-down"></span>Project Reports</a>
     <ul class="nav nav-list">
      <li><a href="changes-report.html" title="Changes"><span class="none"></span>Changes</a></li>
      <li><a href="apidocs/index.html" title="Javadoc"><span class="none"></span>Javadoc</a></li>
      <li><a href="testapidocs/index.html" title="Test Javadoc"><span class="none"></span>Test Javadoc</a></li>
      <li><a href="xref/index.html" title="Source Xref"><span class="none"></span>Source Xref</a></li>
      <li><a href="xref-test/index.html" title="Test Source Xref"><span class="none"></span>Test Source Xref</a></li>
      <li><a href="cpd.html" title="CPD"><span class="none"></span>CPD</a></li>
      <li class="active"><a href="#"><span class="none"></span>PMD</a></li>
      <li><a href="surefire-report.html" title="Surefire Report"><span class="none"></span>Surefire Report</a></li>
      <li><a href="jacoco/index.html" title="JaCoCo"><span class="none"></span>JaCoCo</a></li>
      <li><a href="jacoco-aggregate/index.html" title="JaCoCo Aggregate"><span class="none"></span>JaCoCo Aggregate</a></li>
      <li><a href="jdepend-report.html" title="JDepend"><span class="none"></span>JDepend</a></li>
      <li><a href="rat-report.html" title="Rat Report"><span class="none"></span>Rat Report</a></li>
      <li><a href="taglist.html" title="Tag List"><span class="none"></span>Tag List</a></li>
      <li><a href="findbugs.html" title="FindBugs"><span class="none"></span>FindBugs</a></li>
     </ul></li>
   <li class="nav-header">Apache</li>
    <li><a href="https://www.apache.org/" class="externalLink" title="Apache Website"><span class="none"></span>Apache Website</a></li>
    <li><a href="https://www.apache.org/licenses/" class="externalLink" title="License"><span class="none"></span>License</a></li>
    <li><a href="https://www.apache.org/foundation/how-it-works.html" class="externalLink" title="How the ASF works"><span class="none"></span>How the ASF works</a></li>
    <li><a href="https://www.apache.org/foundation/sponsorship.html" class="externalLink" title="Sponsorship"><span class="none"></span>Sponsorship</a></li>
    <li><a href="https://www.apache.org/foundation/thanks.html" class="externalLink" title="Thanks"><span class="none"></span>Thanks</a></li>
    <li><a href="https://www.apache.org/security/" class="externalLink" title="Security"><span class="none"></span>Security</a></li>
  </ul>
          </nav>
          <div class="well sidebar-nav">
            <hr />
            <div id="poweredBy">
              <div class="clear"></div>
              <div class="clear"></div>
              <div class="clear"></div>
<a href="http://maven.apache.org/" title="Built by Maven" class="poweredBy"><img class="builtBy" alt="Built by Maven" src="./images/logos/maven-feather.png" /></a>
            </div>
          </div>
        </header>
        <main id="bodyColumn"  class="span10" >
<section>
<h2><a name="PMD_Results"></a>PMD Results</h2>
<p>The following document contains the results of <a class="externalLink" href="https://pmd.github.io">PMD</a> 6.29.0.</p></section><section>
<h2><a name="Violations_By_Priority"></a>Violations By Priority</h2><section>
<h3><a name="Priority_1"></a>Priority 1</h3><section>
<h4><a name="org.2Fapache.2Ffulcrum.2Ffactory.2FDefaultFactoryService.java"></a>org/apache/fulcrum/factory/DefaultFactoryService.java</h4>
<table border="0" class="table table-striped">
<tr class="a">
<th>Rule</th>
<th>Violation</th>
<th>Line</th></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#variablenamingconventions">VariableNamingConventions</a></td>
<td>Only variables that are final should contain underscores (except for underscores in standard prefix/suffix), '_factory' is not final.</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L502">502</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablenamingconventions">LocalVariableNamingConventions</a></td>
<td>The local variable name '_factory' doesn't match '[a-z][a-zA-Z0-9]*'</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L502">502</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#avoidthrowingrawexceptiontypes">AvoidThrowingRawExceptionTypes</a></td>
<td>Avoid throwing raw exception types.</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L564">564</a></td></tr></table></section></section><section>
<h3><a name="Priority_2"></a>Priority 2</h3><section>
<h4><a name="org.2Fapache.2Ffulcrum.2Ffactory.2FDefaultFactoryService.java"></a>org/apache/fulcrum/factory/DefaultFactoryService.java</h4>
<table border="0" class="table table-striped">
<tr class="a">
<th>Rule</th>
<th>Violation</th>
<th>Line</th></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#singlemethodsingleton">SingleMethodSingleton</a></td>
<td>Class contains multiple getInstance methods. Please review.</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L51">51</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L581">581</a></td></tr></table></section><section>
<h4><a name="org.2Fapache.2Ffulcrum.2Ffactory.2FFactory.java"></a>org/apache/fulcrum/factory/Factory.java</h4>
<table border="0" class="table table-striped">
<tr class="a">
<th>Rule</th>
<th>Violation</th>
<th>Line</th></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#singlemethodsingleton">SingleMethodSingleton</a></td>
<td>Class contains multiple getInstance methods. Please review.</td>
<td><a href="./xref/org/apache/fulcrum/factory/Factory.html#L34">34</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/Factory.html#L101">101</a></td></tr></table></section><section>
<h4><a name="org.2Fapache.2Ffulcrum.2Ffactory.2FFactoryService.java"></a>org/apache/fulcrum/factory/FactoryService.java</h4>
<table border="0" class="table table-striped">
<tr class="a">
<th>Rule</th>
<th>Violation</th>
<th>Line</th></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#singlemethodsingleton">SingleMethodSingleton</a></td>
<td>Class contains multiple getInstance methods. Please review.</td>
<td><a href="./xref/org/apache/fulcrum/factory/FactoryService.html#L32">32</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/FactoryService.html#L144">144</a></td></tr></table></section></section><section>
<h3><a name="Priority_3"></a>Priority 3</h3><section>
<h4><a name="org.2Fapache.2Ffulcrum.2Ffactory.2FDefaultFactoryService.java"></a>org/apache/fulcrum/factory/DefaultFactoryService.java</h4>
<table border="0" class="table table-striped">
<tr class="a">
<th>Rule</th>
<th>Violation</th>
<th>Line</th></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#atleastoneconstructor">AtLeastOneConstructor</a></td>
<td>Each class should declare at least one constructor</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L51">51</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L581">581</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#godclass">GodClass</a></td>
<td>Possible God Class (WMC=69, ATFD=27, TCC=5.833%)</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L51">51</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L581">581</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_bestpractices.html#loosecoupling">LooseCoupling</a></td>
<td>Avoid using implementation types like 'HashMap'; use the interface instead</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L72">72</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#usediamondoperator">UseDiamondOperator</a></td>
<td>Explicit type arguments can be replaced by Diamond Operator</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L72">72</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#nonstaticinitializer">NonStaticInitializer</a></td>
<td>Non-static initializers are confusing</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L74">74</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L83">83</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#beanmembersshouldserialize">BeanMembersShouldSerialize</a></td>
<td>Found non-transient, non-static member. Please mark as transient or provide accessors.</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L88">88</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#immutablefield">ImmutableField</a></td>
<td>Private field 'classLoaders' could be made final; it is only initialized in the declaration or constructor.</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L92">92</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#beanmembersshouldserialize">BeanMembersShouldSerialize</a></td>
<td>Found non-transient, non-static member. Please mark as transient or provide accessors.</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L92">92</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_bestpractices.html#loosecoupling">LooseCoupling</a></td>
<td>Avoid using implementation types like 'ArrayList'; use the interface instead</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L92">92</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#usediamondoperator">UseDiamondOperator</a></td>
<td>Explicit type arguments can be replaced by Diamond Operator</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L92">92</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#usediamondoperator">UseDiamondOperator</a></td>
<td>Explicit type arguments can be replaced by Diamond Operator</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L96">96</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#beanmembersshouldserialize">BeanMembersShouldSerialize</a></td>
<td>Found non-transient, non-static member. Please mark as transient or provide accessors.</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L96">96</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#immutablefield">ImmutableField</a></td>
<td>Private field 'objectFactories' could be made final; it is only initialized in the declaration or constructor.</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L96">96</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#beanmembersshouldserialize">BeanMembersShouldSerialize</a></td>
<td>Found non-transient, non-static member. Please mark as transient or provide accessors.</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L100">100</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#usediamondoperator">UseDiamondOperator</a></td>
<td>Explicit type arguments can be replaced by Diamond Operator</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L100">100</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#immutablefield">ImmutableField</a></td>
<td>Private field 'objectFactoryClasses' could be made final; it is only initialized in the declaration or constructor.</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L100">100</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#longvariable">LongVariable</a></td>
<td>Avoid excessively long variable names like objectFactoryClasses</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L100">100</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'type' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L108">108</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'className' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L121">121</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'factory' could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L126">126</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#avoidduplicateliterals">AvoidDuplicateLiterals</a></td>
<td>The String literal &quot;Instantiation failed for class &quot; appears 4 times in this file; the first occurrence is on line 132</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L132">132</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#onlyonereturn">OnlyOneReturn</a></td>
<td>A method should have only one exit point, and that should be the last statement in the method</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L134">134</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'className' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L153">153</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'loader' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L153">153</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'factory' could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L155">155</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#confusingternary">ConfusingTernary</a></td>
<td>Avoid if (x != y) ..; else ..;</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L157">157</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L167">167</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#onlyonereturn">OnlyOneReturn</a></td>
<td>A method should have only one exit point, and that should be the last statement in the method</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L164">164</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#onlyonereturn">OnlyOneReturn</a></td>
<td>A method should have only one exit point, and that should be the last statement in the method</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L166">166</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'params' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L185">185</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'className' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L185">185</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'signature' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L185">185</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'factory' could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L187">187</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#onlyonereturn">OnlyOneReturn</a></td>
<td>A method should have only one exit point, and that should be the last statement in the method</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L195">195</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'className' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L220">220</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'signature' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L220">220</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'loader' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L220">220</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'params' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L220">220</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'factory' could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L223">223</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#confusingternary">ConfusingTernary</a></td>
<td>Avoid if (x != y) ..; else ..;</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L225">225</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L235">235</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#onlyonereturn">OnlyOneReturn</a></td>
<td>A method should have only one exit point, and that should be the last statement in the method</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L232">232</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#onlyonereturn">OnlyOneReturn</a></td>
<td>A method should have only one exit point, and that should be the last statement in the method</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L234">234</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'className' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L249">249</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'factory' could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L251">251</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#simplifiedternary">SimplifiedTernary</a></td>
<td>Ternary operators that can be simplified with || or &amp;&amp;</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L252">252</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#confusingternary">ConfusingTernary</a></td>
<td>Avoid if (x != y) ..; else ..;</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L252">252</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'clazz' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L264">264</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#avoidcatchinggenericexception">AvoidCatchingGenericException</a></td>
<td>Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L268">268</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'clazz' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L285">285</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'signature' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L285">285</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'params' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L285">285</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'sign' could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L290">290</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#lawofdemeter">LawOfDemeter</a></td>
<td>Potential violation of Law of Demeter (method chain calls)</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L291">291</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#avoidcatchinggenericexception">AvoidCatchingGenericException</a></td>
<td>Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L292">292</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'signature' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L309">309</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'clazz' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L309">309</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#confusingternary">ConfusingTernary</a></td>
<td>Avoid if (x != y) ..; else ..;</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L312">312</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L342">342</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#useproperclassloader">UseProperClassLoader</a></td>
<td>In J2EE, getClassLoader() might not work as expected.  Use Thread.currentThread().getContextClassLoader() instead.</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L315">315</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'loader' could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L315">315</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#confusingternary">ConfusingTernary</a></td>
<td>Avoid if (x != y) ..; else ..;</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L322">322</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L336">336</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#lawofdemeter">LawOfDemeter</a></td>
<td>Potential violation of Law of Demeter (object not created locally)</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L324">324</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#useproperclassloader">UseProperClassLoader</a></td>
<td>In J2EE, getClassLoader() might not work as expected.  Use Thread.currentThread().getContextClassLoader() instead.</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L325">325</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#lawofdemeter">LawOfDemeter</a></td>
<td>Potential violation of Law of Demeter (object not created locally)</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L327">327</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#useproperclassloader">UseProperClassLoader</a></td>
<td>In J2EE, getClassLoader() might not work as expected.  Use Thread.currentThread().getContextClassLoader() instead.</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L327">327</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#lawofdemeter">LawOfDemeter</a></td>
<td>Potential violation of Law of Demeter (method chain calls)</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L327">327</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#lawofdemeter">LawOfDemeter</a></td>
<td>Potential violation of Law of Demeter (method chain calls)</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L327">327</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#onlyonereturn">OnlyOneReturn</a></td>
<td>A method should have only one exit point, and that should be the last statement in the method</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L339">339</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'object' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L353">353</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'loader' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L353">353</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'bout' could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L355">355</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'out' could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L359">359</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#onlyonereturn">OnlyOneReturn</a></td>
<td>A method should have only one exit point, and that should be the last statement in the method</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L365">365</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'bin' could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L368">368</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#shortvariable">ShortVariable</a></td>
<td>Avoid variables with short names like in</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L369">369</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#onlyonereturn">OnlyOneReturn</a></td>
<td>A method should have only one exit point, and that should be the last statement in the method</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L374">374</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#avoidcatchinggenericexception">AvoidCatchingGenericException</a></td>
<td>Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L376">376</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#emptycatchblock">EmptyCatchBlock</a></td>
<td>Avoid empty catch blocks</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L388">388</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L391">391</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'className' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L404">404</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#useproperclassloader">UseProperClassLoader</a></td>
<td>In J2EE, getClassLoader() might not work as expected.  Use Thread.currentThread().getContextClassLoader() instead.</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L406">406</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'loader' could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L406">406</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#confusingternary">ConfusingTernary</a></td>
<td>Avoid if (x != y) ..; else ..;</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L411">411</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L418">418</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#onlyonereturn">OnlyOneReturn</a></td>
<td>A method should have only one exit point, and that should be the last statement in the method</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L420">420</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'l' could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L425">425</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#emptycatchblock">EmptyCatchBlock</a></td>
<td>Avoid empty catch blocks</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L431">431</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L434">434</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'className' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L450">450</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'loader' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L450">450</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#confusingternary">ConfusingTernary</a></td>
<td>Avoid if (x != y) ..; else ..;</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L452">452</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L459">459</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#onlyonereturn">OnlyOneReturn</a></td>
<td>A method should have only one exit point, and that should be the last statement in the method</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L454">454</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'className' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L471">471</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#onlyonereturn">OnlyOneReturn</a></td>
<td>A method should have only one exit point, and that should be the last statement in the method</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L490">490</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable '_factory' could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L502">502</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'conf' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L520">520</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'nameVal' could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L537">537</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'entry' could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L538">538</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#controlstatementbraces">ControlStatementBraces</a></td>
<td>This statement should have braces</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L538">538</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L539">539</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#forloopsmustusebraces">ForLoopsMustUseBraces</a></td>
<td>Avoid using for statements without curly braces</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L538">538</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L539">539</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'className' could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L555">555</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#lawofdemeter">LawOfDemeter</a></td>
<td>Potential violation of Law of Demeter (method chain calls)</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L559">559</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'loader' could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L559">559</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#avoidcatchinggenericexception">AvoidCatchingGenericException</a></td>
<td>Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L562">562</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#nullassignment">NullAssignment</a></td>
<td>Assigning an Object to null is a code smell.  Consider refactoring.</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L567">567</a></td></tr></table></section><section>
<h4><a name="org.2Fapache.2Ffulcrum.2Ffactory.2FFactoryException.java"></a>org/apache/fulcrum/factory/FactoryException.java</h4>
<table border="0" class="table table-striped">
<tr class="b">
<th>Rule</th>
<th>Violation</th>
<th>Line</th></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'e' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/FactoryException.html#L48">48</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#shortvariable">ShortVariable</a></td>
<td>Avoid variables with short names like e</td>
<td><a href="./xref/org/apache/fulcrum/factory/FactoryException.html#L48">48</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'message' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/FactoryException.html#L48">48</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'e' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/FactoryException.html#L58">58</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#shortvariable">ShortVariable</a></td>
<td>Avoid variables with short names like e</td>
<td><a href="./xref/org/apache/fulcrum/factory/FactoryException.html#L58">58</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'msg' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/FactoryException.html#L68">68</a></td></tr></table></section><section>
<h4><a name="org.2Fapache.2Ffulcrum.2Ffactory.2Futils.2FObjectInputStreamForContext.java"></a>org/apache/fulcrum/factory/utils/ObjectInputStreamForContext.java</h4>
<table border="0" class="table table-striped">
<tr class="a">
<th>Rule</th>
<th>Violation</th>
<th>Line</th></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#beanmembersshouldserialize">BeanMembersShouldSerialize</a></td>
<td>Found non-transient, non-static member. Please mark as transient or provide accessors.</td>
<td><a href="./xref/org/apache/fulcrum/factory/utils/ObjectInputStreamForContext.html#L38">38</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#callsuperinconstructor">CallSuperInConstructor</a></td>
<td>It is a good practice to call super() in a constructor</td>
<td><a href="./xref/org/apache/fulcrum/factory/utils/ObjectInputStreamForContext.html#L45">45</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/utils/ObjectInputStreamForContext.html#L48">48</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#shortvariable">ShortVariable</a></td>
<td>Avoid variables with short names like in</td>
<td><a href="./xref/org/apache/fulcrum/factory/utils/ObjectInputStreamForContext.html#L57">57</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'in' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/utils/ObjectInputStreamForContext.html#L57">57</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'loader' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/utils/ObjectInputStreamForContext.html#L58">58</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_bestpractices.html#missingoverride">MissingOverride</a></td>
<td>The method 'resolveClass(ObjectStreamClass)' is missing an @Override annotation.</td>
<td><a href="./xref/org/apache/fulcrum/factory/utils/ObjectInputStreamForContext.html#L73">73</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/utils/ObjectInputStreamForContext.html#L79">79</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'v' is not assigned and could be declared final</td>
<td><a href="./xref/org/apache/fulcrum/factory/utils/ObjectInputStreamForContext.html#L73">73</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#shortvariable">ShortVariable</a></td>
<td>Avoid variables with short names like v</td>
<td><a href="./xref/org/apache/fulcrum/factory/utils/ObjectInputStreamForContext.html#L73">73</a></td></tr></table></section></section><section>
<h3><a name="Priority_4"></a>Priority 4</h3><section>
<h4><a name="org.2Fapache.2Ffulcrum.2Ffactory.2FDefaultFactoryService.java"></a>org/apache/fulcrum/factory/DefaultFactoryService.java</h4>
<table border="0" class="table table-striped">
<tr class="b">
<th>Rule</th>
<th>Violation</th>
<th>Line</th></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_bestpractices.html#usevarargs">UseVarargs</a></td>
<td>Consider using varargs for methods or constructors which take an array the last parameter.</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L285">285</a></td></tr></table></section><section>
<h4><a name="org.2Fapache.2Ffulcrum.2Ffactory.2FFactory.java"></a>org/apache/fulcrum/factory/Factory.java</h4>
<table border="0" class="table table-striped">
<tr class="b">
<th>Rule</th>
<th>Violation</th>
<th>Line</th></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_bestpractices.html#usevarargs">UseVarargs</a></td>
<td>Consider using varargs for methods or constructors which take an array the last parameter.</td>
<td><a href="./xref/org/apache/fulcrum/factory/Factory.html#L75">75</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_bestpractices.html#usevarargs">UseVarargs</a></td>
<td>Consider using varargs for methods or constructors which take an array the last parameter.</td>
<td><a href="./xref/org/apache/fulcrum/factory/Factory.html#L92">92</a></td></tr></table></section><section>
<h4><a name="org.2Fapache.2Ffulcrum.2Ffactory.2FFactoryService.java"></a>org/apache/fulcrum/factory/FactoryService.java</h4>
<table border="0" class="table table-striped">
<tr class="a">
<th>Rule</th>
<th>Violation</th>
<th>Line</th></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_bestpractices.html#usevarargs">UseVarargs</a></td>
<td>Consider using varargs for methods or constructors which take an array the last parameter.</td>
<td><a href="./xref/org/apache/fulcrum/factory/FactoryService.html#L92">92</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_bestpractices.html#usevarargs">UseVarargs</a></td>
<td>Consider using varargs for methods or constructors which take an array the last parameter.</td>
<td><a href="./xref/org/apache/fulcrum/factory/FactoryService.html#L114">114</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_bestpractices.html#usevarargs">UseVarargs</a></td>
<td>Consider using varargs for methods or constructors which take an array the last parameter.</td>
<td><a href="./xref/org/apache/fulcrum/factory/FactoryService.html#L142">142</a></td></tr></table></section></section><section>
<h3><a name="Priority_5"></a>Priority 5</h3><section>
<h4><a name="org.2Fapache.2Ffulcrum.2Ffactory.2FDefaultFactoryService.java"></a>org/apache/fulcrum/factory/DefaultFactoryService.java</h4>
<table border="0" class="table table-striped">
<tr class="a">
<th>Rule</th>
<th>Violation</th>
<th>Line</th></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#dataflowanomalyanalysis">DataflowAnomalyAnalysis</a></td>
<td>Found 'DU'-anomaly for variable 'clazz' (lines '130'-'138').</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L130">130</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L138">138</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#dataflowanomalyanalysis">DataflowAnomalyAnalysis</a></td>
<td>Found 'DU'-anomaly for variable 'clazz' (lines '160'-'171').</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L160">160</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L171">171</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#dataflowanomalyanalysis">DataflowAnomalyAnalysis</a></td>
<td>Found 'DU'-anomaly for variable 'clazz' (lines '191'-'199').</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L191">191</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L199">199</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#dataflowanomalyanalysis">DataflowAnomalyAnalysis</a></td>
<td>Found 'DU'-anomaly for variable 'clazz' (lines '228'-'239').</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L228">228</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L239">239</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#dataflowanomalyanalysis">DataflowAnomalyAnalysis</a></td>
<td>Found 'DU'-anomaly for variable 'loader' (lines '315'-'343').</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L315">315</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L343">343</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#dataflowanomalyanalysis">DataflowAnomalyAnalysis</a></td>
<td>Found 'DD'-anomaly for variable 'sign' (lines '316'-'319').</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L316">316</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L319">319</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#dataflowanomalyanalysis">DataflowAnomalyAnalysis</a></td>
<td>Found 'DD'-anomaly for variable 'sign' (lines '335'-'319').</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L335">335</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L319">319</a></td></tr></table></section></section></section><section>
<h2><a name="Files"></a>Files</h2><section>
<h3><a name="org.2Fapache.2Ffulcrum.2Ffactory.2FDefaultFactoryService.java"></a>org/apache/fulcrum/factory/DefaultFactoryService.java</h3>
<table border="0" class="table table-striped">
<tr class="a">
<th>Rule</th>
<th>Violation</th>
<th>Priority</th>
<th>Line</th></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#singlemethodsingleton">SingleMethodSingleton</a></td>
<td>Class contains multiple getInstance methods. Please review.</td>
<td>2</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L51">51</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L581">581</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#atleastoneconstructor">AtLeastOneConstructor</a></td>
<td>Each class should declare at least one constructor</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L51">51</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L581">581</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#godclass">GodClass</a></td>
<td>Possible God Class (WMC=69, ATFD=27, TCC=5.833%)</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L51">51</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L581">581</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_bestpractices.html#loosecoupling">LooseCoupling</a></td>
<td>Avoid using implementation types like 'HashMap'; use the interface instead</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L72">72</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#usediamondoperator">UseDiamondOperator</a></td>
<td>Explicit type arguments can be replaced by Diamond Operator</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L72">72</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#nonstaticinitializer">NonStaticInitializer</a></td>
<td>Non-static initializers are confusing</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L74">74</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L83">83</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#beanmembersshouldserialize">BeanMembersShouldSerialize</a></td>
<td>Found non-transient, non-static member. Please mark as transient or provide accessors.</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L88">88</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#immutablefield">ImmutableField</a></td>
<td>Private field 'classLoaders' could be made final; it is only initialized in the declaration or constructor.</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L92">92</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#beanmembersshouldserialize">BeanMembersShouldSerialize</a></td>
<td>Found non-transient, non-static member. Please mark as transient or provide accessors.</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L92">92</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_bestpractices.html#loosecoupling">LooseCoupling</a></td>
<td>Avoid using implementation types like 'ArrayList'; use the interface instead</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L92">92</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#usediamondoperator">UseDiamondOperator</a></td>
<td>Explicit type arguments can be replaced by Diamond Operator</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L92">92</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#usediamondoperator">UseDiamondOperator</a></td>
<td>Explicit type arguments can be replaced by Diamond Operator</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L96">96</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#beanmembersshouldserialize">BeanMembersShouldSerialize</a></td>
<td>Found non-transient, non-static member. Please mark as transient or provide accessors.</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L96">96</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#immutablefield">ImmutableField</a></td>
<td>Private field 'objectFactories' could be made final; it is only initialized in the declaration or constructor.</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L96">96</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#beanmembersshouldserialize">BeanMembersShouldSerialize</a></td>
<td>Found non-transient, non-static member. Please mark as transient or provide accessors.</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L100">100</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#usediamondoperator">UseDiamondOperator</a></td>
<td>Explicit type arguments can be replaced by Diamond Operator</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L100">100</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#immutablefield">ImmutableField</a></td>
<td>Private field 'objectFactoryClasses' could be made final; it is only initialized in the declaration or constructor.</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L100">100</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#longvariable">LongVariable</a></td>
<td>Avoid excessively long variable names like objectFactoryClasses</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L100">100</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'type' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L108">108</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'className' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L121">121</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'factory' could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L126">126</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#dataflowanomalyanalysis">DataflowAnomalyAnalysis</a></td>
<td>Found 'DU'-anomaly for variable 'clazz' (lines '130'-'138').</td>
<td>5</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L130">130</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L138">138</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#avoidduplicateliterals">AvoidDuplicateLiterals</a></td>
<td>The String literal &quot;Instantiation failed for class &quot; appears 4 times in this file; the first occurrence is on line 132</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L132">132</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#onlyonereturn">OnlyOneReturn</a></td>
<td>A method should have only one exit point, and that should be the last statement in the method</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L134">134</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'className' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L153">153</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'loader' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L153">153</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'factory' could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L155">155</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#confusingternary">ConfusingTernary</a></td>
<td>Avoid if (x != y) ..; else ..;</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L157">157</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L167">167</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#dataflowanomalyanalysis">DataflowAnomalyAnalysis</a></td>
<td>Found 'DU'-anomaly for variable 'clazz' (lines '160'-'171').</td>
<td>5</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L160">160</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L171">171</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#onlyonereturn">OnlyOneReturn</a></td>
<td>A method should have only one exit point, and that should be the last statement in the method</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L164">164</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#onlyonereturn">OnlyOneReturn</a></td>
<td>A method should have only one exit point, and that should be the last statement in the method</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L166">166</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'params' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L185">185</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'className' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L185">185</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'signature' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L185">185</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'factory' could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L187">187</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#dataflowanomalyanalysis">DataflowAnomalyAnalysis</a></td>
<td>Found 'DU'-anomaly for variable 'clazz' (lines '191'-'199').</td>
<td>5</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L191">191</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L199">199</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#onlyonereturn">OnlyOneReturn</a></td>
<td>A method should have only one exit point, and that should be the last statement in the method</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L195">195</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'className' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L220">220</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'signature' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L220">220</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'loader' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L220">220</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'params' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L220">220</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'factory' could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L223">223</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#confusingternary">ConfusingTernary</a></td>
<td>Avoid if (x != y) ..; else ..;</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L225">225</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L235">235</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#dataflowanomalyanalysis">DataflowAnomalyAnalysis</a></td>
<td>Found 'DU'-anomaly for variable 'clazz' (lines '228'-'239').</td>
<td>5</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L228">228</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L239">239</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#onlyonereturn">OnlyOneReturn</a></td>
<td>A method should have only one exit point, and that should be the last statement in the method</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L232">232</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#onlyonereturn">OnlyOneReturn</a></td>
<td>A method should have only one exit point, and that should be the last statement in the method</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L234">234</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'className' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L249">249</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'factory' could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L251">251</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#simplifiedternary">SimplifiedTernary</a></td>
<td>Ternary operators that can be simplified with || or &amp;&amp;</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L252">252</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#confusingternary">ConfusingTernary</a></td>
<td>Avoid if (x != y) ..; else ..;</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L252">252</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'clazz' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L264">264</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#avoidcatchinggenericexception">AvoidCatchingGenericException</a></td>
<td>Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L268">268</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_bestpractices.html#usevarargs">UseVarargs</a></td>
<td>Consider using varargs for methods or constructors which take an array the last parameter.</td>
<td>4</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L285">285</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'clazz' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L285">285</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'signature' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L285">285</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'params' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L285">285</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'sign' could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L290">290</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#lawofdemeter">LawOfDemeter</a></td>
<td>Potential violation of Law of Demeter (method chain calls)</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L291">291</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#avoidcatchinggenericexception">AvoidCatchingGenericException</a></td>
<td>Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L292">292</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'signature' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L309">309</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'clazz' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L309">309</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#confusingternary">ConfusingTernary</a></td>
<td>Avoid if (x != y) ..; else ..;</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L312">312</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L342">342</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#useproperclassloader">UseProperClassLoader</a></td>
<td>In J2EE, getClassLoader() might not work as expected.  Use Thread.currentThread().getContextClassLoader() instead.</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L315">315</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'loader' could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L315">315</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#dataflowanomalyanalysis">DataflowAnomalyAnalysis</a></td>
<td>Found 'DU'-anomaly for variable 'loader' (lines '315'-'343').</td>
<td>5</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L315">315</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L343">343</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#dataflowanomalyanalysis">DataflowAnomalyAnalysis</a></td>
<td>Found 'DD'-anomaly for variable 'sign' (lines '316'-'319').</td>
<td>5</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L316">316</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L319">319</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#confusingternary">ConfusingTernary</a></td>
<td>Avoid if (x != y) ..; else ..;</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L322">322</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L336">336</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#lawofdemeter">LawOfDemeter</a></td>
<td>Potential violation of Law of Demeter (object not created locally)</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L324">324</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#useproperclassloader">UseProperClassLoader</a></td>
<td>In J2EE, getClassLoader() might not work as expected.  Use Thread.currentThread().getContextClassLoader() instead.</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L325">325</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#lawofdemeter">LawOfDemeter</a></td>
<td>Potential violation of Law of Demeter (object not created locally)</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L327">327</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#useproperclassloader">UseProperClassLoader</a></td>
<td>In J2EE, getClassLoader() might not work as expected.  Use Thread.currentThread().getContextClassLoader() instead.</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L327">327</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#lawofdemeter">LawOfDemeter</a></td>
<td>Potential violation of Law of Demeter (method chain calls)</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L327">327</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#lawofdemeter">LawOfDemeter</a></td>
<td>Potential violation of Law of Demeter (method chain calls)</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L327">327</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#dataflowanomalyanalysis">DataflowAnomalyAnalysis</a></td>
<td>Found 'DD'-anomaly for variable 'sign' (lines '335'-'319').</td>
<td>5</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L335">335</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L319">319</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#onlyonereturn">OnlyOneReturn</a></td>
<td>A method should have only one exit point, and that should be the last statement in the method</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L339">339</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'object' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L353">353</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'loader' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L353">353</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'bout' could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L355">355</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'out' could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L359">359</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#onlyonereturn">OnlyOneReturn</a></td>
<td>A method should have only one exit point, and that should be the last statement in the method</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L365">365</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'bin' could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L368">368</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#shortvariable">ShortVariable</a></td>
<td>Avoid variables with short names like in</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L369">369</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#onlyonereturn">OnlyOneReturn</a></td>
<td>A method should have only one exit point, and that should be the last statement in the method</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L374">374</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#avoidcatchinggenericexception">AvoidCatchingGenericException</a></td>
<td>Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L376">376</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#emptycatchblock">EmptyCatchBlock</a></td>
<td>Avoid empty catch blocks</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L388">388</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L391">391</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'className' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L404">404</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#useproperclassloader">UseProperClassLoader</a></td>
<td>In J2EE, getClassLoader() might not work as expected.  Use Thread.currentThread().getContextClassLoader() instead.</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L406">406</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'loader' could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L406">406</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#confusingternary">ConfusingTernary</a></td>
<td>Avoid if (x != y) ..; else ..;</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L411">411</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L418">418</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#onlyonereturn">OnlyOneReturn</a></td>
<td>A method should have only one exit point, and that should be the last statement in the method</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L420">420</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'l' could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L425">425</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#emptycatchblock">EmptyCatchBlock</a></td>
<td>Avoid empty catch blocks</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L431">431</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L434">434</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'className' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L450">450</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'loader' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L450">450</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#confusingternary">ConfusingTernary</a></td>
<td>Avoid if (x != y) ..; else ..;</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L452">452</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L459">459</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#onlyonereturn">OnlyOneReturn</a></td>
<td>A method should have only one exit point, and that should be the last statement in the method</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L454">454</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'className' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L471">471</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#onlyonereturn">OnlyOneReturn</a></td>
<td>A method should have only one exit point, and that should be the last statement in the method</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L490">490</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable '_factory' could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L502">502</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#variablenamingconventions">VariableNamingConventions</a></td>
<td>Only variables that are final should contain underscores (except for underscores in standard prefix/suffix), '_factory' is not final.</td>
<td>1</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L502">502</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablenamingconventions">LocalVariableNamingConventions</a></td>
<td>The local variable name '_factory' doesn't match '[a-z][a-zA-Z0-9]*'</td>
<td>1</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L502">502</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'conf' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L520">520</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'nameVal' could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L537">537</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'entry' could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L538">538</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#controlstatementbraces">ControlStatementBraces</a></td>
<td>This statement should have braces</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L538">538</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L539">539</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#forloopsmustusebraces">ForLoopsMustUseBraces</a></td>
<td>Avoid using for statements without curly braces</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L538">538</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L539">539</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'className' could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L555">555</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#lawofdemeter">LawOfDemeter</a></td>
<td>Potential violation of Law of Demeter (method chain calls)</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L559">559</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
<td>Local variable 'loader' could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L559">559</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#avoidcatchinggenericexception">AvoidCatchingGenericException</a></td>
<td>Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L562">562</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_design.html#avoidthrowingrawexceptiontypes">AvoidThrowingRawExceptionTypes</a></td>
<td>Avoid throwing raw exception types.</td>
<td>1</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L564">564</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#nullassignment">NullAssignment</a></td>
<td>Assigning an Object to null is a code smell.  Consider refactoring.</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/DefaultFactoryService.html#L567">567</a></td></tr></table></section><section>
<h3><a name="org.2Fapache.2Ffulcrum.2Ffactory.2FFactory.java"></a>org/apache/fulcrum/factory/Factory.java</h3>
<table border="0" class="table table-striped">
<tr class="b">
<th>Rule</th>
<th>Violation</th>
<th>Priority</th>
<th>Line</th></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#singlemethodsingleton">SingleMethodSingleton</a></td>
<td>Class contains multiple getInstance methods. Please review.</td>
<td>2</td>
<td><a href="./xref/org/apache/fulcrum/factory/Factory.html#L34">34</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/Factory.html#L101">101</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_bestpractices.html#usevarargs">UseVarargs</a></td>
<td>Consider using varargs for methods or constructors which take an array the last parameter.</td>
<td>4</td>
<td><a href="./xref/org/apache/fulcrum/factory/Factory.html#L75">75</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_bestpractices.html#usevarargs">UseVarargs</a></td>
<td>Consider using varargs for methods or constructors which take an array the last parameter.</td>
<td>4</td>
<td><a href="./xref/org/apache/fulcrum/factory/Factory.html#L92">92</a></td></tr></table></section><section>
<h3><a name="org.2Fapache.2Ffulcrum.2Ffactory.2FFactoryException.java"></a>org/apache/fulcrum/factory/FactoryException.java</h3>
<table border="0" class="table table-striped">
<tr class="b">
<th>Rule</th>
<th>Violation</th>
<th>Priority</th>
<th>Line</th></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'e' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/FactoryException.html#L48">48</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#shortvariable">ShortVariable</a></td>
<td>Avoid variables with short names like e</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/FactoryException.html#L48">48</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'message' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/FactoryException.html#L48">48</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'e' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/FactoryException.html#L58">58</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#shortvariable">ShortVariable</a></td>
<td>Avoid variables with short names like e</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/FactoryException.html#L58">58</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'msg' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/FactoryException.html#L68">68</a></td></tr></table></section><section>
<h3><a name="org.2Fapache.2Ffulcrum.2Ffactory.2FFactoryService.java"></a>org/apache/fulcrum/factory/FactoryService.java</h3>
<table border="0" class="table table-striped">
<tr class="a">
<th>Rule</th>
<th>Violation</th>
<th>Priority</th>
<th>Line</th></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#singlemethodsingleton">SingleMethodSingleton</a></td>
<td>Class contains multiple getInstance methods. Please review.</td>
<td>2</td>
<td><a href="./xref/org/apache/fulcrum/factory/FactoryService.html#L32">32</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/FactoryService.html#L144">144</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_bestpractices.html#usevarargs">UseVarargs</a></td>
<td>Consider using varargs for methods or constructors which take an array the last parameter.</td>
<td>4</td>
<td><a href="./xref/org/apache/fulcrum/factory/FactoryService.html#L92">92</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_bestpractices.html#usevarargs">UseVarargs</a></td>
<td>Consider using varargs for methods or constructors which take an array the last parameter.</td>
<td>4</td>
<td><a href="./xref/org/apache/fulcrum/factory/FactoryService.html#L114">114</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_bestpractices.html#usevarargs">UseVarargs</a></td>
<td>Consider using varargs for methods or constructors which take an array the last parameter.</td>
<td>4</td>
<td><a href="./xref/org/apache/fulcrum/factory/FactoryService.html#L142">142</a></td></tr></table></section><section>
<h3><a name="org.2Fapache.2Ffulcrum.2Ffactory.2Futils.2FObjectInputStreamForContext.java"></a>org/apache/fulcrum/factory/utils/ObjectInputStreamForContext.java</h3>
<table border="0" class="table table-striped">
<tr class="b">
<th>Rule</th>
<th>Violation</th>
<th>Priority</th>
<th>Line</th></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_errorprone.html#beanmembersshouldserialize">BeanMembersShouldSerialize</a></td>
<td>Found non-transient, non-static member. Please mark as transient or provide accessors.</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/utils/ObjectInputStreamForContext.html#L38">38</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#callsuperinconstructor">CallSuperInConstructor</a></td>
<td>It is a good practice to call super() in a constructor</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/utils/ObjectInputStreamForContext.html#L45">45</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/utils/ObjectInputStreamForContext.html#L48">48</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#shortvariable">ShortVariable</a></td>
<td>Avoid variables with short names like in</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/utils/ObjectInputStreamForContext.html#L57">57</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'in' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/utils/ObjectInputStreamForContext.html#L57">57</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'loader' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/utils/ObjectInputStreamForContext.html#L58">58</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_bestpractices.html#missingoverride">MissingOverride</a></td>
<td>The method 'resolveClass(ObjectStreamClass)' is missing an @Override annotation.</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/utils/ObjectInputStreamForContext.html#L73">73</a>&#x2013;<a href="./xref/org/apache/fulcrum/factory/utils/ObjectInputStreamForContext.html#L79">79</a></td></tr>
<tr class="a">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
<td>Parameter 'v' is not assigned and could be declared final</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/utils/ObjectInputStreamForContext.html#L73">73</a></td></tr>
<tr class="b">
<td><a class="externalLink" href="https://pmd.github.io/pmd-6.29.0/pmd_rules_java_codestyle.html#shortvariable">ShortVariable</a></td>
<td>Avoid variables with short names like v</td>
<td>3</td>
<td><a href="./xref/org/apache/fulcrum/factory/utils/ObjectInputStreamForContext.html#L73">73</a></td></tr></table></section></section>
        </main>
      </div>
    </div>
    <hr/>
    <footer>
      <div class="container-fluid">
        <div class="row-fluid">
            <p>&#169;      2005&#x2013;2021
<a href="https://www.apache.org/">The Apache Software Foundation</a>
</p>
        </div>
      </div>
    </footer>
  </body>
</html>
