<!DOCTYPE HTML>
<html lang>
<head>
<!-- Generated by javadoc (21) -->
<title>BaseAntTask (Apache Creadur RAT 0.17-SNAPSHOT API)</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="description" content="declaration: package: org.apache.rat.anttasks, class: BaseAntTask">
<meta name="generator" content="javadoc/ClassWriterImpl">
<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../script-dir/jquery-ui.min.css" title="Style">
<script type="text/javascript" src="../../../../script.js"></script>
<script type="text/javascript" src="../../../../script-dir/jquery-3.7.1.min.js"></script>
<script type="text/javascript" src="../../../../script-dir/jquery-ui.min.js"></script>
</head>
<body class="class-declaration-page">
<script type="text/javascript">var pathtoroot = "../../../../";
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="flex-box">
<header role="banner" class="flex-header">
<nav role="navigation">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="top-nav" id="navbar-top"><button id="navbar-toggle-button" aria-controls="navbar-top" aria-expanded="false" aria-label="Toggle navigation links"><span class="nav-bar-toggle-icon">&nbsp;</span><span class="nav-bar-toggle-icon">&nbsp;</span><span class="nav-bar-toggle-icon">&nbsp;</span></button>
<div class="skip-nav"><a href="#skip-navbar-top" title="Skip navigation links">Skip navigation links</a></div>
<ul id="navbar-top-firstrow" class="nav-list" title="Navigation">
<li><a href="../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="nav-bar-cell1-rev">Class</li>
<li><a href="class-use/BaseAntTask.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../index-all.html">Index</a></li>
<li><a href="../../../../help-doc.html#class">Help</a></li>
</ul>
<ul class="sub-nav-list-small">
<li>
<p>Summary:</p>
<ul>
<li><a href="#nested-class-summary">Nested</a></li>
<li><a href="#field-summary">Field</a></li>
<li><a href="#constructor-summary">Constr</a></li>
<li><a href="#method-summary">Method</a></li>
</ul>
</li>
<li>
<p>Detail:</p>
<ul>
<li><a href="#field-detail">Field</a></li>
<li><a href="#constructor-detail">Constr</a></li>
<li><a href="#method-detail">Method</a></li>
</ul>
</li>
</ul>
</div>
<div class="sub-nav">
<div id="navbar-sub-list">
<ul class="sub-nav-list">
<li>Summary:&nbsp;</li>
<li><a href="#nested-class-summary">Nested</a>&nbsp;|&nbsp;</li>
<li><a href="#field-summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor-summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li><a href="#field-detail">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor-detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-detail">Method</a></li>
</ul>
</div>
<div class="nav-list-search"><a href="../../../../search.html">SEARCH</a>
<input type="text" id="search-input" disabled placeholder="Search">
<input type="reset" id="reset-button" disabled value="reset">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.rat.anttasks</a></div>
<h1 title="Class BaseAntTask" class="title">Class BaseAntTask</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">java.lang.Object</a>
<div class="inheritance">org.apache.tools.ant.ProjectComponent
<div class="inheritance">org.apache.tools.ant.Task
<div class="inheritance">org.apache.rat.anttasks.BaseAntTask</div>
</div>
</div>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>All Implemented Interfaces:</dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Cloneable.html" title="class or interface in java.lang" class="external-link">Cloneable</a></code></dd>
</dl>
<dl class="notes">
<dt>Direct Known Subclasses:</dt>
<dd><code><a href="Help.html" title="class in org.apache.rat.anttasks">Help</a></code>, <code><a href="Report.html" title="class in org.apache.rat.anttasks">Report</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public abstract class </span><span class="element-name type-name-label">BaseAntTask</span>
<span class="extends-implements">extends org.apache.tools.ant.Task</span></div>
<div class="block">Generated class to provide Ant support for standard RAT command line options.

 DO NOT EDIT - GENERATED FILE</div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- ======== NESTED CLASS SUMMARY ======== -->
<li>
<section class="nested-class-summary" id="nested-class-summary">
<h2>Nested Class Summary</h2>
<div class="caption"><span>Nested Classes</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Class</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="BaseAntTask.Cntr.html" class="type-name-link" title="class in org.apache.rat.anttasks">BaseAntTask.Cntr</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="BaseAntTask.Config.html" class="type-name-link" title="class in org.apache.rat.anttasks">BaseAntTask.Config</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="BaseAntTask.CounterMax.html" class="type-name-link" title="class in org.apache.rat.anttasks">BaseAntTask.CounterMax</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="BaseAntTask.CounterMin.html" class="type-name-link" title="class in org.apache.rat.anttasks">BaseAntTask.CounterMin</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="BaseAntTask.Exclude.html" class="type-name-link" title="class in org.apache.rat.anttasks">BaseAntTask.Exclude</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="BaseAntTask.Expr.html" class="type-name-link" title="class in org.apache.rat.anttasks">BaseAntTask.Expr</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="BaseAntTask.Filename.html" class="type-name-link" title="class in org.apache.rat.anttasks">BaseAntTask.Filename</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="BaseAntTask.Include.html" class="type-name-link" title="class in org.apache.rat.anttasks">BaseAntTask.Include</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="BaseAntTask.InputExclude.html" class="type-name-link" title="class in org.apache.rat.anttasks">BaseAntTask.InputExclude</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="BaseAntTask.InputExcludeParsedScm.html" class="type-name-link" title="class in org.apache.rat.anttasks">BaseAntTask.InputExcludeParsedScm</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="BaseAntTask.InputInclude.html" class="type-name-link" title="class in org.apache.rat.anttasks">BaseAntTask.InputInclude</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="BaseAntTask.LicenseFamiliesApproved.html" class="type-name-link" title="class in org.apache.rat.anttasks">BaseAntTask.LicenseFamiliesApproved</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="BaseAntTask.LicenseFamiliesDenied.html" class="type-name-link" title="class in org.apache.rat.anttasks">BaseAntTask.LicenseFamiliesDenied</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="BaseAntTask.Licenses.html" class="type-name-link" title="class in org.apache.rat.anttasks">BaseAntTask.Licenses</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="BaseAntTask.LicensesApproved.html" class="type-name-link" title="class in org.apache.rat.anttasks">BaseAntTask.LicensesApproved</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="BaseAntTask.LicensesDenied.html" class="type-name-link" title="class in org.apache.rat.anttasks">BaseAntTask.LicensesDenied</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="BaseAntTask.Lst.html" class="type-name-link" title="class in org.apache.rat.anttasks">BaseAntTask.Lst</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="BaseAntTask.Std.html" class="type-name-link" title="class in org.apache.rat.anttasks">BaseAntTask.Std</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>protected static class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="BaseAntTask.TxtValue.html" class="type-name-link" title="class in org.apache.rat.anttasks">BaseAntTask.TxtValue</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
</div>
</section>
</li>
<!-- =========== FIELD SUMMARY =========== -->
<li>
<section class="field-summary" id="field-summary">
<h2>Field Summary</h2>
<div class="caption"><span>Fields</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Field</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>protected final <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a><wbr>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#args" class="member-name-link">args</a></code></div>
<div class="col-last even-row-color">
<div class="block">A map of CLI-based arguments to values.</div>
</div>
</div>
<div class="inherited-list">
<h3 id="fields-inherited-from-class-org.apache.tools.ant.Task">Fields inherited from class&nbsp;org.apache.tools.ant.Task</h3>
<code>target, taskName, taskType, wrapper</code></div>
<div class="inherited-list">
<h3 id="fields-inherited-from-class-org.apache.tools.ant.ProjectComponent">Fields inherited from class&nbsp;org.apache.tools.ant.ProjectComponent</h3>
<code>description, location, project</code></div>
</section>
</li>
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<li>
<section class="constructor-summary" id="constructor-summary">
<h2>Constructor Summary</h2>
<div class="caption"><span>Constructors</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier</div>
<div class="table-header col-second">Constructor</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>protected </code></div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E()" class="member-name-link">BaseAntTask</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab1" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab1', 3)" class="table-tab">Static Methods</button><button id="method-summary-table-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance Methods</button><button id="method-summary-table-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button><button id="method-summary-table-tab6" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab6', 3)" class="table-tab">Deprecated Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#addArg(java.lang.String,java.lang.String)" class="member-name-link">addArg</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Add a value to the key in the argument list.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#addArg(java.lang.String,java.lang.String%5B%5D)" class="member-name-link">addArg</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Add values to the key in the argument list.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a><wbr>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#args()" class="member-name-link">args</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Gets the list of arguments prepared for the CLI code to parse.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="BaseAntTask.Config.html" title="class in org.apache.rat.anttasks">BaseAntTask.Config</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#createConfig()" class="member-name-link">createConfig</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">File names for system configuration.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="BaseAntTask.CounterMax.html" title="class in org.apache.rat.anttasks">BaseAntTask.CounterMax</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#createCounterMax()" class="member-name-link">createCounterMax</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">The acceptable maximum number for the specified counter.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="BaseAntTask.CounterMin.html" title="class in org.apache.rat.anttasks">BaseAntTask.CounterMin</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#createCounterMin()" class="member-name-link">createCounterMin</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">The minimum number for the specified counter.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="BaseAntTask.Exclude.html" title="class in org.apache.rat.anttasks">BaseAntTask.Exclude</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#createExclude()" class="member-name-link">createExclude</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use &lt;inputExclude&gt; instead.</div>
</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="BaseAntTask.Include.html" title="class in org.apache.rat.anttasks">BaseAntTask.Include</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#createInclude()" class="member-name-link">createInclude</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use &lt;inputInclude&gt; instead.</div>
</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="BaseAntTask.InputExclude.html" title="class in org.apache.rat.anttasks">BaseAntTask.InputExclude</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#createInputExclude()" class="member-name-link">createInputExclude</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Excludes files matching &lt;Expression&gt;.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="BaseAntTask.InputExcludeParsedScm.html" title="class in org.apache.rat.anttasks">BaseAntTask.InputExcludeParsedScm</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#createInputExcludeParsedScm()" class="member-name-link">createInputExcludeParsedScm</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Parse SCM based exclusion files to exclude specified files and directories.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="BaseAntTask.InputInclude.html" title="class in org.apache.rat.anttasks">BaseAntTask.InputInclude</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#createInputInclude()" class="member-name-link">createInputInclude</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Includes files matching &lt;Expression&gt;.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="BaseAntTask.LicenseFamiliesApproved.html" title="class in org.apache.rat.anttasks">BaseAntTask.LicenseFamiliesApproved</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#createLicenseFamiliesApproved()" class="member-name-link">createLicenseFamiliesApproved</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">A comma separated list of approved license family IDs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="BaseAntTask.LicenseFamiliesDenied.html" title="class in org.apache.rat.anttasks">BaseAntTask.LicenseFamiliesDenied</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#createLicenseFamiliesDenied()" class="member-name-link">createLicenseFamiliesDenied</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">A comma separated list of denied License family IDs.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="BaseAntTask.Licenses.html" title="class in org.apache.rat.anttasks">BaseAntTask.Licenses</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#createLicenses()" class="member-name-link">createLicenses</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use &lt;config&gt; instead.</div>
</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="BaseAntTask.LicensesApproved.html" title="class in org.apache.rat.anttasks">BaseAntTask.LicensesApproved</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#createLicensesApproved()" class="member-name-link">createLicensesApproved</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">A comma separated list of approved License IDs.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="BaseAntTask.LicensesDenied.html" title="class in org.apache.rat.anttasks">BaseAntTask.LicensesDenied</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#createLicensesDenied()" class="member-name-link">createLicensesDenied</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">A comma separated list of denied License IDs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#createName(java.lang.String)" class="member-name-link">createName</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;longOpt)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a><wbr>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getArg(java.lang.String)" class="member-name-link">getArg</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Get the list of values for a key.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#removeArg(java.lang.String)" class="member-name-link">removeArg</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Remove a key from the argument list.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#setAddLicense(boolean)" class="member-name-link">setAddLicense</a><wbr>(boolean&nbsp;addLicense)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use editLicense attribute instead.</div>
</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setArg(java.lang.String,java.lang.String)" class="member-name-link">setArg</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Set a key and value into the argument list.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setConfigurationNoDefaults(boolean)" class="member-name-link">setConfigurationNoDefaults</a><wbr>(boolean&nbsp;configurationNoDefaults)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Ignore default configuration.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#setCopyright(java.lang.String)" class="member-name-link">setCopyright</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;copyright)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use editCopyright attribute instead.</div>
</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setDryRun(boolean)" class="member-name-link">setDryRun</a><wbr>(boolean&nbsp;dryRun)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">If set do not update the files but generate the reports.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setEditCopyright(java.lang.String)" class="member-name-link">setEditCopyright</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;editCopyright)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">The copyright message to use in the license headers.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setEditLicense(boolean)" class="member-name-link">setEditLicense</a><wbr>(boolean&nbsp;editLicense)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Add the Apache-2.0 license header to any file with an unknown license that is not in the exclusion list.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setEditOverwrite(boolean)" class="member-name-link">setEditOverwrite</a><wbr>(boolean&nbsp;editOverwrite)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Forces any changes in files to be written directly to the source files so that new files are not created.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#setExcludeFile(java.lang.String)" class="member-name-link">setExcludeFile</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;excludeFile)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use inputExcludeFile attribute instead.</div>
</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#setForce(boolean)" class="member-name-link">setForce</a><wbr>(boolean&nbsp;force)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use editOverwrite attribute instead.</div>
</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setHelpLicenses(boolean)" class="member-name-link">setHelpLicenses</a><wbr>(boolean&nbsp;helpLicenses)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Print information about registered licenses.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#setIncludesFile(java.lang.String)" class="member-name-link">setIncludesFile</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;includesFile)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use inputIncludeFile attribute instead.</div>
</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setInputExcludeSize(java.lang.String)" class="member-name-link">setInputExcludeSize</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;inputExcludeSize)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Excludes files with sizes less than the number of bytes specified.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#setListFamilies(java.lang.String)" class="member-name-link">setListFamilies</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;listFamilies)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use outputFamilies attribute instead.</div>
</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#setListLicenses(java.lang.String)" class="member-name-link">setListLicenses</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;listLicenses)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use outputLicenses attribute instead.</div>
</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#setNoDefaultLicenses(boolean)" class="member-name-link">setNoDefaultLicenses</a><wbr>(boolean&nbsp;noDefaultLicenses)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use configurationNoDefaults attribute instead.</div>
</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#setOut(java.lang.String)" class="member-name-link">setOut</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;out)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use outputFile attribute instead.</div>
</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setOutputArchive(java.lang.String)" class="member-name-link">setOutputArchive</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;outputArchive)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Specifies the level of detail in ARCHIVE file reporting.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setOutputFamilies(java.lang.String)" class="member-name-link">setOutputFamilies</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;outputFamilies)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">List the defined license families.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setOutputFile(java.lang.String)" class="member-name-link">setOutputFile</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;outputFile)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Define the output file where to write a report to.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setOutputLicenses(java.lang.String)" class="member-name-link">setOutputLicenses</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;outputLicenses)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">List the defined licenses.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setOutputStandard(java.lang.String)" class="member-name-link">setOutputStandard</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;outputStandard)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Specifies the level of detail in STANDARD file reporting.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setOutputStyle(java.lang.String)" class="member-name-link">setOutputStyle</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;outputStyle)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">XSLT stylesheet to use when creating the report.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#setScanHiddenDirectories(boolean)" class="member-name-link">setScanHiddenDirectories</a><wbr>(boolean&nbsp;scanHiddenDirectories)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use &lt;inputIncludeStd&gt; with 'HIDDEN_DIR' argument instead.</div>
</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#setStylesheet(java.lang.String)" class="member-name-link">setStylesheet</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stylesheet)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use outputStyle attribute instead.</div>
</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#setXml(boolean)" class="member-name-link">setXml</a><wbr>(boolean&nbsp;xml)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use outputStyle attribute with the 'xml' argument instead.</div>
</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a><wbr>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#unsupportedArgs()" class="member-name-link">unsupportedArgs</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-org.apache.tools.ant.Task">Methods inherited from class&nbsp;org.apache.tools.ant.Task</h3>
<code>bindToOwner, execute, getOwningTarget, getRuntimeConfigurableWrapper, getTaskName, getTaskType, getWrapper, handleErrorFlush, handleErrorOutput, handleFlush, handleInput, handleOutput, init, isInvalid, log, log, log, log, maybeConfigure, perform, reconfigure, setOwningTarget, setRuntimeConfigurableWrapper, setTaskName, setTaskType</code></div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-org.apache.tools.ant.ProjectComponent">Methods inherited from class&nbsp;org.apache.tools.ant.ProjectComponent</h3>
<code>clone, getDescription, getLocation, getProject, setDescription, setLocation, setProject</code></div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.lang.Object">Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></h3>
<code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#equals-java.lang.Object-" title="class or interface in java.lang" class="external-link">equals</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#finalize--" title="class or interface in java.lang" class="external-link">finalize</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#getClass--" title="class or interface in java.lang" class="external-link">getClass</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#hashCode--" title="class or interface in java.lang" class="external-link">hashCode</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#notify--" title="class or interface in java.lang" class="external-link">notify</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#notifyAll--" title="class or interface in java.lang" class="external-link">notifyAll</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#toString--" title="class or interface in java.lang" class="external-link">toString</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#wait--" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#wait-long-" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#wait-long-int-" title="class or interface in java.lang" class="external-link">wait</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ============ FIELD DETAIL =========== -->
<li>
<section class="field-details" id="field-detail">
<h2>Field Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="args">
<h3>args</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&gt;</span>&nbsp;<span class="element-name">args</span></div>
<div class="block">A map of CLI-based arguments to values.</div>
</section>
</li>
</ul>
</section>
</li>
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<li>
<section class="constructor-details" id="constructor-detail">
<h2>Constructor Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="&lt;init&gt;()">
<h3>BaseAntTask</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="element-name">BaseAntTask</span>()</div>
</section>
</li>
</ul>
</section>
</li>
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="createName(java.lang.String)">
<h3>createName</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">createName</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;longOpt)</span></div>
</section>
</li>
<li>
<section class="detail" id="unsupportedArgs()">
<h3>unsupportedArgs</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">unsupportedArgs</span>()</div>
</section>
</li>
<li>
<section class="detail" id="args()">
<h3>args</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">args</span>()</div>
<div class="block">Gets the list of arguments prepared for the CLI code to parse.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the List of arguments for the CLI command line.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setArg(java.lang.String,java.lang.String)">
<h3>setArg</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setArg</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value)</span></div>
<div class="block">Set a key and value into the argument list.
 Replaces any existing value.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - the key for the map.</dd>
<dd><code>value</code> - the value to set.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getArg(java.lang.String)">
<h3>getArg</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">getArg</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</span></div>
<div class="block">Get the list of values for a key.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - the key for the map.</dd>
<dt>Returns:</dt>
<dd>the list of values for the key or <code>null</code> if not set.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="addArg(java.lang.String,java.lang.String[])">
<h3>addArg</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">addArg</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]&nbsp;value)</span></div>
<div class="block">Add values to the key in the argument list.
 empty values are ignored. If no non-empty values are present no change is made.
 If the key does not exist, adds it.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - the key for the map.</dd>
<dd><code>value</code> - the array of values to set.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="addArg(java.lang.String,java.lang.String)">
<h3>addArg</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">addArg</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value)</span></div>
<div class="block">Add a value to the key in the argument list.
 If the key does not exist, adds it.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - the key for the map.</dd>
<dd><code>value</code> - the value to set.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="removeArg(java.lang.String)">
<h3>removeArg</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">removeArg</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</span></div>
<div class="block">Remove a key from the argument list.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - the key to remove from the map.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setCopyright(java.lang.String)">
<h3>setCopyright</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setCopyright</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;copyright)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use editCopyright attribute instead.</div>
</div>
<div class="block">The copyright message to use in the license headers.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>copyright</code> - Copyright message to use in the license headers.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setEditCopyright(java.lang.String)">
<h3>setEditCopyright</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setEditCopyright</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;editCopyright)</span></div>
<div class="block">The copyright message to use in the license headers. Usually in the form of &quot;Copyright 2008 Foo&quot;.  Only valid with editLicense attribute</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>editCopyright</code> - Copyright message to use in the license headers.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setForce(boolean)">
<h3>setForce</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setForce</span><wbr><span class="parameters">(boolean&nbsp;force)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use editOverwrite attribute instead.</div>
</div>
<div class="block">Forces any changes in files to be written directly to the source files so that new files are not created.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>force</code> - The state</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setEditOverwrite(boolean)">
<h3>setEditOverwrite</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setEditOverwrite</span><wbr><span class="parameters">(boolean&nbsp;editOverwrite)</span></div>
<div class="block">Forces any changes in files to be written directly to the source files so that new files are not created. Only valid with editLicense attribute.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>editOverwrite</code> - The state</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setAddLicense(boolean)">
<h3>setAddLicense</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setAddLicense</span><wbr><span class="parameters">(boolean&nbsp;addLicense)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use editLicense attribute instead.</div>
</div>
<div class="block">Add the Apache-2.0 license header to any file with an unknown license that is not in the exclusion list.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>addLicense</code> - The state</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setEditLicense(boolean)">
<h3>setEditLicense</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setEditLicense</span><wbr><span class="parameters">(boolean&nbsp;editLicense)</span></div>
<div class="block">Add the Apache-2.0 license header to any file with an unknown license that is not in the exclusion list. By default new files will be created with the license header, to force the modification of existing files use the editOverwrite attribute option.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>editLicense</code> - The state</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setConfigurationNoDefaults(boolean)">
<h3>setConfigurationNoDefaults</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setConfigurationNoDefaults</span><wbr><span class="parameters">(boolean&nbsp;configurationNoDefaults)</span></div>
<div class="block">Ignore default configuration.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>configurationNoDefaults</code> - The state</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setNoDefaultLicenses(boolean)">
<h3>setNoDefaultLicenses</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setNoDefaultLicenses</span><wbr><span class="parameters">(boolean&nbsp;noDefaultLicenses)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use configurationNoDefaults attribute instead.</div>
</div>
<div class="block">Ignore default configuration.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>noDefaultLicenses</code> - The state</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setExcludeFile(java.lang.String)">
<h3>setExcludeFile</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setExcludeFile</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;excludeFile)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use inputExcludeFile attribute instead.</div>
</div>
<div class="block">Reads &lt;Expression&gt; entries from a file. Entries will be excluded from processing. Argument should be a File. (See Argument Types for clarification)</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>excludeFile</code> - &lt;Expression&gt; entries from a file.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setInputExcludeSize(java.lang.String)">
<h3>setInputExcludeSize</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setInputExcludeSize</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;inputExcludeSize)</span></div>
<div class="block">Excludes files with sizes less than the number of bytes specified. Argument should be a Integer. (See Argument Types for clarification)</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>inputExcludeSize</code> - Files with sizes less than the number of bytes specified.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setIncludesFile(java.lang.String)">
<h3>setIncludesFile</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setIncludesFile</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;includesFile)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use inputIncludeFile attribute instead.</div>
</div>
<div class="block">Reads &lt;Expression&gt; entries from a file. Entries will be excluded from processing. Argument should be a File. (See Argument Types for clarification)</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>includesFile</code> - &lt;Expression&gt; entries from a file.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setScanHiddenDirectories(boolean)">
<h3>setScanHiddenDirectories</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setScanHiddenDirectories</span><wbr><span class="parameters">(boolean&nbsp;scanHiddenDirectories)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use &lt;inputIncludeStd&gt; with 'HIDDEN_DIR' argument instead.</div>
</div>
<div class="block">Scans hidden directories.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>scanHiddenDirectories</code> - The state</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setOutputStyle(java.lang.String)">
<h3>setOutputStyle</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setOutputStyle</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;outputStyle)</span></div>
<div class="block">XSLT stylesheet to use when creating the report. Either an external xsl file may be specified or one of the internal named sheets. Argument should be a StyleSheet. (See Argument Types for clarification)</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>outputStyle</code> - Stylesheet to use when creating the report.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setStylesheet(java.lang.String)">
<h3>setStylesheet</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setStylesheet</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stylesheet)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use outputStyle attribute instead.</div>
</div>
<div class="block">XSLT stylesheet to use when creating the report. Argument should be a StyleSheet. (See Argument Types for clarification)</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>stylesheet</code> - Stylesheet to use when creating the report.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setXml(boolean)">
<h3>setXml</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setXml</span><wbr><span class="parameters">(boolean&nbsp;xml)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use outputStyle attribute with the 'xml' argument instead.</div>
</div>
<div class="block">forces XML output rather than the textual report.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>xml</code> - The state</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setOutputLicenses(java.lang.String)">
<h3>setOutputLicenses</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setOutputLicenses</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;outputLicenses)</span></div>
<div class="block">List the defined licenses. Argument should be a LicenseFilter. (See Argument Types for clarification)</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>outputLicenses</code> - The defined licenses.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setListLicenses(java.lang.String)">
<h3>setListLicenses</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setListLicenses</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;listLicenses)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use outputLicenses attribute instead.</div>
</div>
<div class="block">List the defined licenses. Argument should be a LicenseFilter. (See Argument Types for clarification)</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>listLicenses</code> - The defined licenses.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setOutputFamilies(java.lang.String)">
<h3>setOutputFamilies</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setOutputFamilies</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;outputFamilies)</span></div>
<div class="block">List the defined license families. Argument should be a LicenseFilter. (See Argument Types for clarification)</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>outputFamilies</code> - The defined license families.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setListFamilies(java.lang.String)">
<h3>setListFamilies</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setListFamilies</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;listFamilies)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use outputFamilies attribute instead.</div>
</div>
<div class="block">List the defined license families. Argument should be a LicenseFilter. (See Argument Types for clarification)</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>listFamilies</code> - The defined license families.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setDryRun(boolean)">
<h3>setDryRun</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setDryRun</span><wbr><span class="parameters">(boolean&nbsp;dryRun)</span></div>
<div class="block">If set do not update the files but generate the reports.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>dryRun</code> - The state</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setOut(java.lang.String)">
<h3>setOut</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setOut</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;out)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use outputFile attribute instead.</div>
</div>
<div class="block">Define the output file where to write a report to. Argument should be a File. (See Argument Types for clarification)</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>out</code> - The output file where to write a report to.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setOutputFile(java.lang.String)">
<h3>setOutputFile</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setOutputFile</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;outputFile)</span></div>
<div class="block">Define the output file where to write a report to. Argument should be a File. (See Argument Types for clarification)</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>outputFile</code> - The output file where to write a report to.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setOutputArchive(java.lang.String)">
<h3>setOutputArchive</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setOutputArchive</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;outputArchive)</span></div>
<div class="block">Specifies the level of detail in ARCHIVE file reporting. Argument should be a ProcessingType. (See Argument Types for clarification)</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>outputArchive</code> - The level of detail in ARCHIVE file reporting.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setOutputStandard(java.lang.String)">
<h3>setOutputStandard</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setOutputStandard</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;outputStandard)</span></div>
<div class="block">Specifies the level of detail in STANDARD file reporting. Argument should be a ProcessingType. (See Argument Types for clarification)</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>outputStandard</code> - The level of detail in STANDARD file reporting.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setHelpLicenses(boolean)">
<h3>setHelpLicenses</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setHelpLicenses</span><wbr><span class="parameters">(boolean&nbsp;helpLicenses)</span></div>
<div class="block">Print information about registered licenses.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>helpLicenses</code> - The state</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="createConfig()">
<h3>createConfig</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="BaseAntTask.Config.html" title="class in org.apache.rat.anttasks">BaseAntTask.Config</a></span>&nbsp;<span class="element-name">createConfig</span>()</div>
<div class="block">File names for system configuration.</div>
</section>
</li>
<li>
<section class="detail" id="createLicenses()">
<h3>createLicenses</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="BaseAntTask.Licenses.html" title="class in org.apache.rat.anttasks">BaseAntTask.Licenses</a></span>&nbsp;<span class="element-name">createLicenses</span>()</div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use &lt;config&gt; instead.</div>
</div>
<div class="block">File names for system configuration.</div>
</section>
</li>
<li>
<section class="detail" id="createLicensesApproved()">
<h3>createLicensesApproved</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="BaseAntTask.LicensesApproved.html" title="class in org.apache.rat.anttasks">BaseAntTask.LicensesApproved</a></span>&nbsp;<span class="element-name">createLicensesApproved</span>()</div>
<div class="block">A comma separated list of approved License IDs. These licenses will be added to the list of approved licenses.</div>
</section>
</li>
<li>
<section class="detail" id="createLicenseFamiliesApproved()">
<h3>createLicenseFamiliesApproved</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="BaseAntTask.LicenseFamiliesApproved.html" title="class in org.apache.rat.anttasks">BaseAntTask.LicenseFamiliesApproved</a></span>&nbsp;<span class="element-name">createLicenseFamiliesApproved</span>()</div>
<div class="block">A comma separated list of approved license family IDs. These license families will be added to the list of approved license families.</div>
</section>
</li>
<li>
<section class="detail" id="createLicensesDenied()">
<h3>createLicensesDenied</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="BaseAntTask.LicensesDenied.html" title="class in org.apache.rat.anttasks">BaseAntTask.LicensesDenied</a></span>&nbsp;<span class="element-name">createLicensesDenied</span>()</div>
<div class="block">A comma separated list of denied License IDs. These licenses will be removed from the list of approved licenses. Once licenses are removed they can not be added back.</div>
</section>
</li>
<li>
<section class="detail" id="createLicenseFamiliesDenied()">
<h3>createLicenseFamiliesDenied</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="BaseAntTask.LicenseFamiliesDenied.html" title="class in org.apache.rat.anttasks">BaseAntTask.LicenseFamiliesDenied</a></span>&nbsp;<span class="element-name">createLicenseFamiliesDenied</span>()</div>
<div class="block">A comma separated list of denied License family IDs. These license families will be removed from the list of approved licenses. Once license families are removed they can not be added back.</div>
</section>
</li>
<li>
<section class="detail" id="createCounterMax()">
<h3>createCounterMax</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="BaseAntTask.CounterMax.html" title="class in org.apache.rat.anttasks">BaseAntTask.CounterMax</a></span>&nbsp;<span class="element-name">createCounterMax</span>()</div>
<div class="block">The acceptable maximum number for the specified counter. A value of '-1' specifies an unlimited number.</div>
</section>
</li>
<li>
<section class="detail" id="createCounterMin()">
<h3>createCounterMin</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="BaseAntTask.CounterMin.html" title="class in org.apache.rat.anttasks">BaseAntTask.CounterMin</a></span>&nbsp;<span class="element-name">createCounterMin</span>()</div>
<div class="block">The minimum number for the specified counter.</div>
</section>
</li>
<li>
<section class="detail" id="createExclude()">
<h3>createExclude</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="BaseAntTask.Exclude.html" title="class in org.apache.rat.anttasks">BaseAntTask.Exclude</a></span>&nbsp;<span class="element-name">createExclude</span>()</div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use &lt;inputExclude&gt; instead.</div>
</div>
<div class="block">Excludes files matching &lt;Expression&gt;.</div>
</section>
</li>
<li>
<section class="detail" id="createInputExclude()">
<h3>createInputExclude</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="BaseAntTask.InputExclude.html" title="class in org.apache.rat.anttasks">BaseAntTask.InputExclude</a></span>&nbsp;<span class="element-name">createInputExclude</span>()</div>
<div class="block">Excludes files matching &lt;Expression&gt;.</div>
</section>
</li>
<li>
<section class="detail" id="createInputInclude()">
<h3>createInputInclude</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="BaseAntTask.InputInclude.html" title="class in org.apache.rat.anttasks">BaseAntTask.InputInclude</a></span>&nbsp;<span class="element-name">createInputInclude</span>()</div>
<div class="block">Includes files matching &lt;Expression&gt;. Will override excluded files.</div>
</section>
</li>
<li>
<section class="detail" id="createInclude()">
<h3>createInclude</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="BaseAntTask.Include.html" title="class in org.apache.rat.anttasks">BaseAntTask.Include</a></span>&nbsp;<span class="element-name">createInclude</span>()</div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Deprecated for removal since 0.17: Use &lt;inputInclude&gt; instead.</div>
</div>
<div class="block">Includes files matching &lt;Expression&gt;. Will override excluded files.</div>
</section>
</li>
<li>
<section class="detail" id="createInputExcludeParsedScm()">
<h3>createInputExcludeParsedScm</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="BaseAntTask.InputExcludeParsedScm.html" title="class in org.apache.rat.anttasks">BaseAntTask.InputExcludeParsedScm</a></span>&nbsp;<span class="element-name">createInputExcludeParsedScm</span>()</div>
<div class="block">Parse SCM based exclusion files to exclude specified files and directories. This action can apply to any standard collection that implements a file processor.</div>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright &#169; 2006&#x2013;2025 <a href="https://www.apache.org">Apache Software Foundation</a>. All rights reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
