<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>HashTree (Apache JMeter dist 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.jorphan.collections, class: HashTree">
<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">
<link rel="stylesheet" type="text/css" href="../../../../jquery-ui.overrides.css" title="Style">
<script type="text/javascript" src="../../../../script.js"></script>
<script type="text/javascript" src="../../../../script-dir/jquery-3.5.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 evenRowColor = "even-row-color";
var oddRowColor = "odd-row-color";
var tableTab = "table-tab";
var activeTableTab = "active-table-tab";
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">
<div class="skip-nav"><a href="#skip-navbar-top" title="Skip navigation links">Skip navigation links</a></div>
<div class="about-language"><b>Apache JMeter</b></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="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>
</div>
<div class="sub-nav">
<div>
<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"><label for="search-input">SEARCH:</label>
<input type="text" id="search-input" value="search" disabled="disabled">
<input type="reset" id="reset-button" value="reset" disabled="disabled">
</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.jorphan.collections</a></div>
<h1 title="Class HashTree" class="title">Class HashTree</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.jorphan.collections.HashTree</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/io/Serializable.html" title="class or interface in java.io" class="external-link">Serializable</a></code>, <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>, <code><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/Object.html" title="class or interface in java.lang" class="external-link">Object</a>,<wbr><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&gt;</code></dd>
</dl>
<dl class="notes">
<dt>Direct Known Subclasses:</dt>
<dd><code><a href="ListedHashTree.html" title="class in org.apache.jorphan.collections">ListedHashTree</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public class </span><span class="element-name type-name-label">HashTree</span>
<span class="extends-implements">extends <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>
implements <a href="https://docs.oracle.com/javase/8/docs/api/java/io/Serializable.html" title="class or interface in java.io" class="external-link">Serializable</a>, <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/Object.html" title="class or interface in java.lang" class="external-link">Object</a>,<wbr><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&gt;, <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></span></div>
<div class="block">This class is used to create a tree structure of objects. Each element in the
 tree is also a key to the next node down in the tree. It provides many ways
 to add objects and branches, as well as many ways to retrieve.
 <p>
 HashTree implements the Map interface for convenience reasons. The main
 difference between a Map and a HashTree is that the HashTree organizes the
 data into a recursive tree structure, and provides the means to manipulate
 that structure.
 <p>
 Of special interest is the <a href="#traverse(org.apache.jorphan.collections.HashTreeTraverser)"><code>traverse(HashTreeTraverser)</code></a> method, which
 provides an expedient way to traverse any HashTree by implementing the
 <a href="HashTreeTraverser.html" title="interface in org.apache.jorphan.collections"><code>HashTreeTraverser</code></a> interface in order to perform some operation on the
 tree, or to extract information from the tree.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="HashTreeTraverser.html" title="interface in org.apache.jorphan.collections"><code>HashTreeTraverser</code></a></li>
<li><a href="SearchByClass.html" title="class in org.apache.jorphan.collections"><code>SearchByClass</code></a></li>
<li><a href="../../../../serialized-form.html#org.apache.jorphan.collections.HashTree">Serialized Form</a></li>
</ul>
</dd>
</dl>
</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="inherited-list">
<h2 id="nested-classes-inherited-from-class-java.util.Map">Nested classes/interfaces inherited from interface&nbsp;java.util.<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></h2>
<code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.Entry.html" title="class or interface in java.util" class="external-link">Map.Entry</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.Entry.html" title="class or interface in java.util" class="external-link">K</a> extends <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>,<wbr><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.Entry.html" title="class or interface in java.util" class="external-link">V</a> extends <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>&gt;</code></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>&lt;<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>,<wbr><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#data" class="member-name-link">data</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
</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>&nbsp;</code></div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E()" class="member-name-link">HashTree</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Creates an empty new HashTree.</div>
</div>
<div class="col-first odd-row-color"><code>&nbsp;</code></div>
<div class="col-constructor-name odd-row-color"><code><a href="#%3Cinit%3E(java.lang.Object)" class="member-name-link">HashTree</a><wbr>(<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>&nbsp;key)</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a new HashTree and adds the given object as a top-level node.</div>
</div>
<div class="col-first even-row-color"><code>&nbsp;</code></div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E(java.lang.Object%5B%5D)" class="member-name-link">HashTree</a><wbr>(<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>[]&nbsp;keys)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a new HashTree and adds all the objects in the given array as
 top-level nodes in the tree.</div>
</div>
<div class="col-first odd-row-color"><code>&nbsp;</code></div>
<div class="col-constructor-name odd-row-color"><code><a href="#%3Cinit%3E(java.util.Collection)" class="member-name-link">HashTree</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;keys)</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a new HashTree and adds all the objects in the given collection
 as top-level nodes in the tree.</div>
</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(java.util.Map)" class="member-name-link">HashTree</a><wbr>(<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/Object.html" title="class or interface in java.lang" class="external-link">Object</a>,<wbr><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&gt;&nbsp;_map)</code></div>
<div class="col-last even-row-color">
<div class="block">Allow subclasses to provide their own Map.</div>
</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-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></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><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#add(java.lang.Object)" class="member-name-link">add</a><wbr>(<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>&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">Adds an key into the HashTree at the current level.</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="#add(java.lang.Object%5B%5D)" class="member-name-link">add</a><wbr>(<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>[]&nbsp;keys)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Adds all the given objects as nodes at the current level.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#add(java.lang.Object%5B%5D,java.lang.Object)" class="member-name-link">add</a><wbr>(<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>[]&nbsp;treePath,
 <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>&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 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>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#add(java.lang.Object%5B%5D,java.lang.Object%5B%5D)" class="member-name-link">add</a><wbr>(<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>[]&nbsp;treePath,
 <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>[]&nbsp;values)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Adds a series of nodes into the HashTree using the given path.</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="#add(java.lang.Object%5B%5D,java.util.Collection)" class="member-name-link">add</a><wbr>(<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>[]&nbsp;treePath,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;values)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Adds a series of nodes into the HashTree using the given path.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#add(java.lang.Object,java.lang.Object)" class="member-name-link">add</a><wbr>(<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>&nbsp;key,
 <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>&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">Adds a key and it's value in the HashTree.</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="#add(java.lang.Object,java.lang.Object%5B%5D)" class="member-name-link">add</a><wbr>(<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>&nbsp;key,
 <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>[]&nbsp;values)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Adds a key and it's values in the HashTree.</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="#add(java.lang.Object,java.util.Collection)" class="member-name-link">add</a><wbr>(<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>&nbsp;key,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;values)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Adds a key as a node at the current level and then adds all the objects
 in the second argument as nodes of the new node.</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="#add(java.lang.Object,org.apache.jorphan.collections.HashTree)" class="member-name-link">add</a><wbr>(<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>&nbsp;key,
 <a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&nbsp;subTree)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Adds a key as a node at the current level and then adds the given
 HashTree to that new node.</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="#add(java.util.Collection)" class="member-name-link">add</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;keys)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Adds a bunch of keys into the HashTree at the current level.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#add(java.util.Collection,java.lang.Object)" class="member-name-link">add</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;treePath,
 <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>&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">Adds a series of nodes into the HashTree using the given path.</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="#add(java.util.Collection,java.lang.Object%5B%5D)" class="member-name-link">add</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;treePath,
 <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>[]&nbsp;values)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Adds a series of nodes into the HashTree using the given path.</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="#add(java.util.Collection,java.util.Collection)" class="member-name-link">add</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;treePath,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;values)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Adds a series of nodes into the HashTree using the given path.</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="#add(org.apache.jorphan.collections.HashTree)" class="member-name-link">add</a><wbr>(<a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&nbsp;newTree)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Adds all the nodes and branches of the given tree to this tree.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#addTreePath(java.util.Collection)" class="member-name-link">addTreePath</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;treePath)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 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>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#clear()" class="member-name-link">clear</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Clears the HashTree of all contents.</div>
</div>
<div class="col-first even-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/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#clone()" class="member-name-link">clone</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Create a clone of this HashTree.</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="#cloneTree(org.apache.jorphan.collections.HashTree)" class="member-name-link">cloneTree</a><wbr>(<a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&nbsp;newTree)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#containsKey(java.lang.Object)" class="member-name-link">containsKey</a><wbr>(<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>&nbsp;o)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">If the HashTree contains the given object as a key at the top level, then
 a true result is returned, otherwise false.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#containsValue(java.lang.Object)" class="member-name-link">containsValue</a><wbr>(<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>&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">Implemented as required by the Map interface, but is not very useful
 here.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#createNewTree()" class="member-name-link">createNewTree</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Creates a new tree.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#createNewTree(java.lang.Object)" class="member-name-link">createNewTree</a><wbr>(<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>&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">Creates a new tree.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#createNewTree(java.util.Collection)" class="member-name-link">createNewTree</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;values)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Creates a new tree.</div>
</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/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.Entry.html" title="class or interface in java.util" class="external-link">Map.Entry</a>&lt;<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>,<wbr><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&gt;&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#entrySet()" class="member-name-link">entrySet</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Exists to satisfy the Map interface.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#equals(java.lang.Object)" class="member-name-link">equals</a><wbr>(<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>&nbsp;o)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Compares all objects in the tree and verifies that the two trees contain
 the same objects at the same tree levels.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#get(java.lang.Object)" class="member-name-link">get</a><wbr>(<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>&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">Returns the HashTree object associated with the given key.</div>
</div>
<div class="col-first even-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/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>[]</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getArray()" class="member-name-link">getArray</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 an array of all keys in the current HashTree node.</div>
</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/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>[]</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getArray(java.lang.Object)" class="member-name-link">getArray</a><wbr>(<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>&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">Gets an array of all keys in the HashTree mapped to the given key of the
 current HashTree object (in other words, one level down).</div>
</div>
<div class="col-first even-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/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>[]</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getArray(java.lang.Object%5B%5D)" class="member-name-link">getArray</a><wbr>(<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>[]&nbsp;treePath)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Recurses down into the HashTree structure using each subsequent key in the
 array of keys, and returns an array of keys of the HashTree object at the
 end of the recursion.</div>
</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/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>[]</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getArray(java.util.Collection)" class="member-name-link">getArray</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;treePath)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Recurses down into the HashTree structure using each subsequent key in the
 treePath argument, and returns an array of keys of the HashTree object at
 the end of the recursion.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getTree(java.lang.Object)" class="member-name-link">getTree</a><wbr>(<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>&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">Gets the HashTree mapped to the given key.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getTree(java.lang.Object%5B%5D)" class="member-name-link">getTree</a><wbr>(<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>[]&nbsp;treePath)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Gets the HashTree object mapped to the last key in the array by recursing
 through the HashTree structure one key at a time.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getTree(java.util.Collection)" class="member-name-link">getTree</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;treePath)</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 HashTree object mapped to the last key in the SortedSet by
 recursing through the HashTree structure one key at a time.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getTreePath(java.util.Collection)" class="member-name-link">getTreePath</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;treePath)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#hashCode()" class="member-name-link">hashCode</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns a hashcode for this HashTree.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#isEmpty()" class="member-name-link">isEmpty</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">If the HashTree is empty, true is returned, false otherwise.</div>
</div>
<div class="col-first even-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/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<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>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#keySet()" class="member-name-link">keySet</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns a Set of all the keys in the top-level of this HashTree.</div>
</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/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;<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>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#list()" class="member-name-link">list</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Gets a Collection of all keys in the current HashTree node.</div>
</div>
<div class="col-first even-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/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#list(java.lang.Object)" class="member-name-link">list</a><wbr>(<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>&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">Gets a Set of all keys in the HashTree mapped to the given key of the
 current HashTree object (in other words, one level down.</div>
</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/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#list(java.lang.Object%5B%5D)" class="member-name-link">list</a><wbr>(<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>[]&nbsp;treePath)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Recurses down into the HashTree structure using each subsequent key in the
 array of keys, and returns the Set of keys of the HashTree object at the
 end of the recursion.</div>
</div>
<div class="col-first even-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/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#list(java.util.Collection)" class="member-name-link">list</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;treePath)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Recurses down into the HashTree structure using each subsequent key in the
 List of keys, and returns the Set of keys of the HashTree object at the
 end of the recursion.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#put(java.lang.Object,org.apache.jorphan.collections.HashTree)" class="member-name-link">put</a><wbr>(<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>&nbsp;key,
 <a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</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">This is the same as calling HashTree.add(key,value).</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="#putAll(java.util.Map)" class="member-name-link">putAll</a><wbr>(<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;?,<wbr>? extends <a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&gt;&nbsp;map)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">The Map given must also be a HashTree, otherwise an
 UnsupportedOperationException is thrown.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#remove(java.lang.Object)" class="member-name-link">remove</a><wbr>(<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>&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">Removes the entire branch specified by the given key.</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="#replaceKey(java.lang.Object,java.lang.Object)" class="member-name-link">replaceKey</a><wbr>(<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>&nbsp;currentKey,
 <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>&nbsp;newKey)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Finds the given current key, and replaces it with the given new key.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#search(java.lang.Object)" class="member-name-link">search</a><wbr>(<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>&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">Searches the HashTree structure for the given key.</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="#set(java.lang.Object%5B%5D,java.lang.Object%5B%5D)" class="member-name-link">set</a><wbr>(<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>[]&nbsp;treePath,
 <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>[]&nbsp;values)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a series of keys into the HashTree.</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="#set(java.lang.Object%5B%5D,java.util.Collection)" class="member-name-link">set</a><wbr>(<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>[]&nbsp;treePath,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;values)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a series of keys into the HashTree.</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="#set(java.lang.Object,java.lang.Object)" class="member-name-link">set</a><wbr>(<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>&nbsp;key,
 <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>&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">Sets a key and it's value in the HashTree.</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="#set(java.lang.Object,java.lang.Object%5B%5D)" class="member-name-link">set</a><wbr>(<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>&nbsp;key,
 <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>[]&nbsp;values)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a key and its values in the HashTree.</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="#set(java.lang.Object,java.util.Collection)" class="member-name-link">set</a><wbr>(<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>&nbsp;key,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;values)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a key and its values in the HashTree.</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="#set(java.lang.Object,org.apache.jorphan.collections.HashTree)" class="member-name-link">set</a><wbr>(<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>&nbsp;key,
 <a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&nbsp;t)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a key into the current tree and assigns it a HashTree as its
 subtree.</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="#set(java.util.Collection)" class="member-name-link">set</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;values)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the nodes of the current tree to be the objects of the given
 collection.</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="#set(java.util.Collection,java.lang.Object%5B%5D)" class="member-name-link">set</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;treePath,
 <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>[]&nbsp;values)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a series of keys into the HashTree.</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="#set(java.util.Collection,java.util.Collection)" class="member-name-link">set</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;treePath,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;values)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a series of keys into the HashTree.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#size()" class="member-name-link">size</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the number of top-level entries in the HashTree.</div>
</div>
<div class="col-first even-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/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-tab2 method-summary-table-tab4"><code><a href="#toString()" class="member-name-link">toString</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Generate a printable representation of the tree.</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="#traverse(org.apache.jorphan.collections.HashTreeTraverser)" class="member-name-link">traverse</a><wbr>(<a href="HashTreeTraverser.html" title="interface in org.apache.jorphan.collections">HashTreeTraverser</a>&nbsp;visitor)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Allows any implementation of the HashTreeTraverser interface to easily
 traverse (depth-first) all the nodes of the HashTree.</div>
</div>
<div class="col-first even-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/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;<a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</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="#values()" class="member-name-link">values</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns a collection of all the sub-trees of the current tree.</div>
</div>
</div>
</div>
</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#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#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#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>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.util.Map">Methods inherited from interface&nbsp;java.util.<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></h3>
<code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#compute(K,java.util.function.BiFunction)" title="class or interface in java.util" class="external-link">compute</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#computeIfAbsent(K,java.util.function.Function)" title="class or interface in java.util" class="external-link">computeIfAbsent</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#computeIfPresent(K,java.util.function.BiFunction)" title="class or interface in java.util" class="external-link">computeIfPresent</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#forEach(java.util.function.BiConsumer)" title="class or interface in java.util" class="external-link">forEach</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#getOrDefault(java.lang.Object,V)" title="class or interface in java.util" class="external-link">getOrDefault</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#merge(K,V,java.util.function.BiFunction)" title="class or interface in java.util" class="external-link">merge</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#putIfAbsent(K,V)" title="class or interface in java.util" class="external-link">putIfAbsent</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#remove(java.lang.Object,java.lang.Object)" title="class or interface in java.util" class="external-link">remove</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#replace(K,V)" title="class or interface in java.util" class="external-link">replace</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#replace(K,V,V)" title="class or interface in java.util" class="external-link">replace</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#replaceAll(java.util.function.BiFunction)" title="class or interface in java.util" class="external-link">replaceAll</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="data">
<h3>data</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/Object.html" title="class or interface in java.lang" class="external-link">Object</a>,<wbr><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&gt;</span>&nbsp;<span class="element-name">data</span></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>HashTree</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">HashTree</span>()</div>
<div class="block">Creates an empty new HashTree.</div>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(java.util.Map)">
<h3>HashTree</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="element-name">HashTree</span><wbr><span class="parameters">(<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/Object.html" title="class or interface in java.lang" class="external-link">Object</a>,<wbr><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&gt;&nbsp;_map)</span></div>
<div class="block">Allow subclasses to provide their own Map.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>_map</code> - <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link"><code>Map</code></a> to use</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(java.lang.Object)">
<h3>HashTree</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">HashTree</span><wbr><span class="parameters">(<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>&nbsp;key)</span></div>
<div class="block">Creates a new HashTree and adds the given object as a top-level node.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - name of the new top-level node</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(java.util.Collection)">
<h3>HashTree</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">HashTree</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;keys)</span></div>
<div class="block">Creates a new HashTree and adds all the objects in the given collection
 as top-level nodes in the tree.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>keys</code> - a collection of objects to be added to the created HashTree.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(java.lang.Object[])">
<h3>HashTree</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">HashTree</span><wbr><span class="parameters">(<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>[]&nbsp;keys)</span></div>
<div class="block">Creates a new HashTree and adds all the objects in the given array as
 top-level nodes in the tree.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>keys</code> - array with names for the new top-level nodes</dd>
</dl>
</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="putAll(java.util.Map)">
<h3>putAll</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">putAll</span><wbr><span class="parameters">(<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;?,<wbr>? extends <a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&gt;&nbsp;map)</span></div>
<div class="block">The Map given must also be a HashTree, otherwise an
 UnsupportedOperationException is thrown. If it is a HashTree, this is
 like calling the add(HashTree) method.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#putAll(java.util.Map)" title="class or interface in java.util" class="external-link">putAll</a></code>&nbsp;in interface&nbsp;<code><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/Object.html" title="class or interface in java.lang" class="external-link">Object</a>,<wbr><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&gt;</code></dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="#add(java.lang.Object)"><code>add(HashTree)</code></a></li>
<li><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#putAll(java.util.Map)" title="class or interface in java.util" class="external-link"><code>Map.putAll(Map)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="entrySet()">
<h3>entrySet</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/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.Entry.html" title="class or interface in java.util" class="external-link">Map.Entry</a>&lt;<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>,<wbr><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&gt;&gt;</span>&nbsp;<span class="element-name">entrySet</span>()</div>
<div class="block">Exists to satisfy the Map interface.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#entrySet()" title="class or interface in java.util" class="external-link">entrySet</a></code>&nbsp;in interface&nbsp;<code><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/Object.html" title="class or interface in java.lang" class="external-link">Object</a>,<wbr><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&gt;</code></dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#entrySet()" title="class or interface in java.util" class="external-link"><code>Map.entrySet()</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="containsValue(java.lang.Object)">
<h3>containsValue</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">containsValue</span><wbr><span class="parameters">(<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>&nbsp;value)</span></div>
<div class="block">Implemented as required by the Map interface, but is not very useful
 here. All 'values' in a HashTree are HashTree's themselves.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#containsValue(java.lang.Object)" title="class or interface in java.util" class="external-link">containsValue</a></code>&nbsp;in interface&nbsp;<code><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/Object.html" title="class or interface in java.lang" class="external-link">Object</a>,<wbr><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&gt;</code></dd>
<dt>Parameters:</dt>
<dd><code>value</code> - Object to be tested as a value.</dd>
<dt>Returns:</dt>
<dd>True if the HashTree contains the value, false otherwise.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#containsValue(java.lang.Object)" title="class or interface in java.util" class="external-link"><code>Map.containsValue(Object)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="put(java.lang.Object,org.apache.jorphan.collections.HashTree)">
<h3>put</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></span>&nbsp;<span class="element-name">put</span><wbr><span class="parameters">(<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>&nbsp;key,
 <a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&nbsp;value)</span></div>
<div class="block">This is the same as calling HashTree.add(key,value).</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#put(K,V)" title="class or interface in java.util" class="external-link">put</a></code>&nbsp;in interface&nbsp;<code><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/Object.html" title="class or interface in java.lang" class="external-link">Object</a>,<wbr><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&gt;</code></dd>
<dt>Parameters:</dt>
<dd><code>key</code> - to use</dd>
<dd><code>value</code> - to store against key</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#put(K,V)" title="class or interface in java.util" class="external-link"><code>Map.put(Object, Object)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="clear()">
<h3>clear</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">clear</span>()</div>
<div class="block">Clears the HashTree of all contents.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#clear()" title="class or interface in java.util" class="external-link">clear</a></code>&nbsp;in interface&nbsp;<code><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/Object.html" title="class or interface in java.lang" class="external-link">Object</a>,<wbr><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&gt;</code></dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#clear()" title="class or interface in java.util" class="external-link"><code>Map.clear()</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="values()">
<h3>values</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/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;<a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&gt;</span>&nbsp;<span class="element-name">values</span>()</div>
<div class="block">Returns a collection of all the sub-trees of the current tree.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#values()" title="class or interface in java.util" class="external-link">values</a></code>&nbsp;in interface&nbsp;<code><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/Object.html" title="class or interface in java.lang" class="external-link">Object</a>,<wbr><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&gt;</code></dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#values()" title="class or interface in java.util" class="external-link"><code>Map.values()</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="add(java.lang.Object,org.apache.jorphan.collections.HashTree)">
<h3>add</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">add</span><wbr><span class="parameters">(<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>&nbsp;key,
 <a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&nbsp;subTree)</span></div>
<div class="block">Adds a key as a node at the current level and then adds the given
 HashTree to that new node.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - key to create in this tree</dd>
<dd><code>subTree</code> - sub tree to add to the node created for the first argument.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="add(org.apache.jorphan.collections.HashTree)">
<h3>add</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">add</span><wbr><span class="parameters">(<a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&nbsp;newTree)</span></div>
<div class="block">Adds all the nodes and branches of the given tree to this tree. Is like
 merging two trees. Duplicates are ignored.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>newTree</code> - the tree to be added</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="containsKey(java.lang.Object)">
<h3>containsKey</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">containsKey</span><wbr><span class="parameters">(<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>&nbsp;o)</span></div>
<div class="block">If the HashTree contains the given object as a key at the top level, then
 a true result is returned, otherwise false.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#containsKey(java.lang.Object)" title="class or interface in java.util" class="external-link">containsKey</a></code>&nbsp;in interface&nbsp;<code><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/Object.html" title="class or interface in java.lang" class="external-link">Object</a>,<wbr><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&gt;</code></dd>
<dt>Parameters:</dt>
<dd><code>o</code> - Object to be tested as a key.</dd>
<dt>Returns:</dt>
<dd>True if the HashTree contains the key, false otherwise.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#containsKey(java.lang.Object)" title="class or interface in java.util" class="external-link"><code>Map.containsKey(Object)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isEmpty()">
<h3>isEmpty</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isEmpty</span>()</div>
<div class="block">If the HashTree is empty, true is returned, false otherwise.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#isEmpty()" title="class or interface in java.util" class="external-link">isEmpty</a></code>&nbsp;in interface&nbsp;<code><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/Object.html" title="class or interface in java.lang" class="external-link">Object</a>,<wbr><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>True if HashTree is empty, false otherwise.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="set(java.lang.Object,java.lang.Object)">
<h3>set</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">set</span><wbr><span class="parameters">(<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>&nbsp;key,
 <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>&nbsp;value)</span></div>
<div class="block">Sets a key and it's value in the HashTree. It actually sets up a key, and
 then creates a node for the key and sets the value to the new node, as a
 key. Any previous nodes that existed under the given key are lost.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - key to be set up</dd>
<dd><code>value</code> - value to be set up as a key in the secondary node</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="set(java.lang.Object,org.apache.jorphan.collections.HashTree)">
<h3>set</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">set</span><wbr><span class="parameters">(<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>&nbsp;key,
 <a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&nbsp;t)</span></div>
<div class="block">Sets a key into the current tree and assigns it a HashTree as its
 subtree. Any previous entries under the given key are removed.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - key to be set up</dd>
<dd><code>t</code> - HashTree that the key maps to</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="set(java.lang.Object,java.lang.Object[])">
<h3>set</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">set</span><wbr><span class="parameters">(<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>&nbsp;key,
 <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>[]&nbsp;values)</span></div>
<div class="block">Sets a key and its values in the HashTree. It sets up a key in the
 current node, and then creates a node for that key, and sets all the
 values in the array as keys in the new node. Any keys previously held
 under the given key are lost.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - Key to be set up</dd>
<dd><code>values</code> - Array of objects to be added as keys in the secondary node</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="set(java.lang.Object,java.util.Collection)">
<h3>set</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">set</span><wbr><span class="parameters">(<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>&nbsp;key,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;values)</span></div>
<div class="block">Sets a key and its values in the HashTree. It sets up a key in the
 current node, and then creates a node for that key, and set all the
 values in the array as keys in the new node. Any keys previously held
 under the given key are removed.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - key to be set up</dd>
<dd><code>values</code> - Collection of objects to be added as keys in the secondary
            node</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="set(java.lang.Object[],java.lang.Object[])">
<h3>set</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">set</span><wbr><span class="parameters">(<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>[]&nbsp;treePath,
 <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>[]&nbsp;values)</span></div>
<div class="block">Sets a series of keys into the HashTree. It sets up the first object in
 the key array as a key in the current node, recurses into the next
 HashTree node through that key and adds the second object in the array.
 Continues recursing in this manner until the end of the first array is
 reached, at which point all the values of the second array are set as
 keys to the bottom-most node. All previous keys of that bottom-most node
 are removed.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>treePath</code> - array of keys to put into HashTree</dd>
<dd><code>values</code> - array of values to be added as keys to bottom-most node</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="set(java.lang.Object[],java.util.Collection)">
<h3>set</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">set</span><wbr><span class="parameters">(<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>[]&nbsp;treePath,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;values)</span></div>
<div class="block">Sets a series of keys into the HashTree. It sets up the first object in
 the key array as a key in the current node, recurses into the next
 HashTree node through that key and adds the second object in the array.
 Continues recursing in this manner until the end of the first array is
 reached, at which point all the values of the Collection of values are
 set as keys to the bottom-most node. Any keys previously held by the
 bottom-most node are lost.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>treePath</code> - array of keys to put into HashTree</dd>
<dd><code>values</code> - Collection of values to be added as keys to bottom-most node</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="set(java.util.Collection,java.lang.Object[])">
<h3>set</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">set</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;treePath,
 <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>[]&nbsp;values)</span></div>
<div class="block">Sets a series of keys into the HashTree. It sets up the first object in
 the key list as a key in the current node, recurses into the next
 HashTree node through that key and adds the second object in the list.
 Continues recursing in this manner until the end of the first list is
 reached, at which point all the values of the array of values are set as
 keys to the bottom-most node. Any previously existing keys of that bottom
 node are removed.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>treePath</code> - collection of keys to put into HashTree</dd>
<dd><code>values</code> - array of values to be added as keys to bottom-most node</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="set(java.util.Collection)">
<h3>set</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">set</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;values)</span></div>
<div class="block">Sets the nodes of the current tree to be the objects of the given
 collection. Any nodes previously in the tree are removed.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>values</code> - Collection of objects to set as nodes.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="set(java.util.Collection,java.util.Collection)">
<h3>set</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">set</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;treePath,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;values)</span></div>
<div class="block">Sets a series of keys into the HashTree. It sets up the first object in
 the key list as a key in the current node, recurses into the next
 HashTree node through that key and adds the second object in the list.
 Continues recursing in this manner until the end of the first list is
 reached, at which point all the values of the Collection of values are
 set as keys to the bottom-most node. Any previously existing keys of that
 bottom node are lost.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>treePath</code> - list of keys to put into HashTree</dd>
<dd><code>values</code> - collection of values to be added as keys to bottom-most node</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="add(java.lang.Object)">
<h3>add</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></span>&nbsp;<span class="element-name">add</span><wbr><span class="parameters">(<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>&nbsp;key)</span></div>
<div class="block">Adds an key into the HashTree at the current level. If a HashTree exists
 for the key already, no new tree will be added</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - key to be added to HashTree</dd>
<dt>Returns:</dt>
<dd>newly generated tree, if no tree was found for the given key;
         existing key otherwise</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="add(java.lang.Object[])">
<h3>add</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">add</span><wbr><span class="parameters">(<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>[]&nbsp;keys)</span></div>
<div class="block">Adds all the given objects as nodes at the current level.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>keys</code> - Array of Keys to be added to HashTree.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="add(java.util.Collection)">
<h3>add</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">add</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;keys)</span></div>
<div class="block">Adds a bunch of keys into the HashTree at the current level.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>keys</code> - Collection of Keys to be added to HashTree.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="add(java.lang.Object,java.lang.Object)">
<h3>add</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></span>&nbsp;<span class="element-name">add</span><wbr><span class="parameters">(<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>&nbsp;key,
 <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>&nbsp;value)</span></div>
<div class="block">Adds a key and it's value in the HashTree. The first argument becomes a
 node at the current level, and the second argument becomes a node of it.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - key to be added</dd>
<dd><code>value</code> - value to be added as a key in the secondary node</dd>
<dt>Returns:</dt>
<dd>HashTree for which <code>value</code> is the key</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="add(java.lang.Object,java.lang.Object[])">
<h3>add</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">add</span><wbr><span class="parameters">(<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>&nbsp;key,
 <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>[]&nbsp;values)</span></div>
<div class="block">Adds a key and it's values in the HashTree. The first argument becomes a
 node at the current level, and adds all the values in the array to the
 new node.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - key to be added</dd>
<dd><code>values</code> - array of objects to be added as keys in the secondary node</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="add(java.lang.Object,java.util.Collection)">
<h3>add</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">add</span><wbr><span class="parameters">(<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>&nbsp;key,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;values)</span></div>
<div class="block">Adds a key as a node at the current level and then adds all the objects
 in the second argument as nodes of the new node.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - key to be added</dd>
<dd><code>values</code> - Collection of objects to be added as keys in the secondary
            node</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="add(java.lang.Object[],java.lang.Object[])">
<h3>add</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">add</span><wbr><span class="parameters">(<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>[]&nbsp;treePath,
 <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>[]&nbsp;values)</span></div>
<div class="block">Adds a series of nodes into the HashTree using the given path. The first
 argument is an array that represents a path to a specific node in the
 tree. If the path doesn't already exist, it is created (the objects are
 added along the way). At the path, all the objects in the second argument
 are added as nodes.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>treePath</code> - an array of objects representing a path</dd>
<dd><code>values</code> - array of values to be added as keys to bottom-most node</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="add(java.lang.Object[],java.util.Collection)">
<h3>add</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">add</span><wbr><span class="parameters">(<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>[]&nbsp;treePath,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;values)</span></div>
<div class="block">Adds a series of nodes into the HashTree using the given path. The first
 argument is an array that represents a path to a specific node in the
 tree. If the path doesn't already exist, it is created (the objects are
 added along the way). At the path, all the objects in the second argument
 are added as nodes.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>treePath</code> - an array of objects representing a path</dd>
<dd><code>values</code> - collection of values to be added as keys to bottom-most node</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="add(java.lang.Object[],java.lang.Object)">
<h3>add</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></span>&nbsp;<span class="element-name">add</span><wbr><span class="parameters">(<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>[]&nbsp;treePath,
 <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>&nbsp;value)</span></div>
</section>
</li>
<li>
<section class="detail" id="add(java.util.Collection,java.lang.Object[])">
<h3>add</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">add</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;treePath,
 <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>[]&nbsp;values)</span></div>
<div class="block">Adds a series of nodes into the HashTree using the given path. The first
 argument is a List that represents a path to a specific node in the tree.
 If the path doesn't already exist, it is created (the objects are added
 along the way). At the path, all the objects in the second argument are
 added as nodes.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>treePath</code> - a list of objects representing a path</dd>
<dd><code>values</code> - array of values to be added as keys to bottom-most node</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="add(java.util.Collection,java.lang.Object)">
<h3>add</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></span>&nbsp;<span class="element-name">add</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;treePath,
 <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>&nbsp;value)</span></div>
<div class="block">Adds a series of nodes into the HashTree using the given path. The first
 argument is a List that represents a path to a specific node in the tree.
 If the path doesn't already exist, it is created (the objects are added
 along the way). At the path, the object in the second argument is added
 as a node.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>treePath</code> - a list of objects representing a path</dd>
<dd><code>value</code> - Object to add as a node to bottom-most node</dd>
<dt>Returns:</dt>
<dd>HashTree for which <code>value</code> is the key</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="add(java.util.Collection,java.util.Collection)">
<h3>add</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">add</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;treePath,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;values)</span></div>
<div class="block">Adds a series of nodes into the HashTree using the given path. The first
 argument is a SortedSet that represents a path to a specific node in the
 tree. If the path doesn't already exist, it is created (the objects are
 added along the way). At the path, all the objects in the second argument
 are added as nodes.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>treePath</code> - a SortedSet of objects representing a path</dd>
<dd><code>values</code> - Collection of values to be added as keys to bottom-most node</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="addTreePath(java.util.Collection)">
<h3>addTreePath</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></span>&nbsp;<span class="element-name">addTreePath</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;treePath)</span></div>
</section>
</li>
<li>
<section class="detail" id="getTree(java.lang.Object)">
<h3>getTree</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></span>&nbsp;<span class="element-name">getTree</span><wbr><span class="parameters">(<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>&nbsp;key)</span></div>
<div class="block">Gets the HashTree mapped to the given key.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - Key used to find appropriate HashTree()</dd>
<dt>Returns:</dt>
<dd>the HashTree for <code>key</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="get(java.lang.Object)">
<h3>get</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></span>&nbsp;<span class="element-name">get</span><wbr><span class="parameters">(<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>&nbsp;key)</span></div>
<div class="block">Returns the HashTree object associated with the given key. Same as
 calling <a href="#getTree(java.lang.Object)"><code>getTree(Object)</code></a>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#get(java.lang.Object)" title="class or interface in java.util" class="external-link">get</a></code>&nbsp;in interface&nbsp;<code><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/Object.html" title="class or interface in java.lang" class="external-link">Object</a>,<wbr><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&gt;</code></dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#get(java.lang.Object)" title="class or interface in java.util" class="external-link"><code>Map.get(Object)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getTree(java.lang.Object[])">
<h3>getTree</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></span>&nbsp;<span class="element-name">getTree</span><wbr><span class="parameters">(<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>[]&nbsp;treePath)</span></div>
<div class="block">Gets the HashTree object mapped to the last key in the array by recursing
 through the HashTree structure one key at a time.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>treePath</code> - array of keys.</dd>
<dt>Returns:</dt>
<dd>HashTree at the end of the recursion.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="clone()">
<h3>clone</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/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></span>&nbsp;<span class="element-name">clone</span>()</div>
<div class="block">Create a clone of this HashTree. This is not a deep clone (i.e., the
 contents of the tree are not cloned).</div>
<dl class="notes">
<dt>Overrides:</dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#clone()" title="class or interface in java.lang" class="external-link">clone</a></code>&nbsp;in class&nbsp;<code><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></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="cloneTree(org.apache.jorphan.collections.HashTree)">
<h3>cloneTree</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">cloneTree</span><wbr><span class="parameters">(<a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&nbsp;newTree)</span></div>
</section>
</li>
<li>
<section class="detail" id="createNewTree()">
<h3>createNewTree</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></span>&nbsp;<span class="element-name">createNewTree</span>()</div>
<div class="block">Creates a new tree. This method exists to allow inheriting classes to
 generate the appropriate types of nodes. For instance, when a node is
 added, it's value is a HashTree. Rather than directly calling the
 HashTree() constructor, the createNewTree() method is called. Inheriting
 classes should override these methods and create the appropriate subclass
 of HashTree.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>HashTree</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="createNewTree(java.lang.Object)">
<h3>createNewTree</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></span>&nbsp;<span class="element-name">createNewTree</span><wbr><span class="parameters">(<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>&nbsp;key)</span></div>
<div class="block">Creates a new tree. This method exists to allow inheriting classes to
 generate the appropriate types of nodes. For instance, when a node is
 added, it's value is a HashTree. Rather than directly calling the
 HashTree() constructor, the createNewTree() method is called. Inheriting
 classes should override these methods and create the appropriate subclass
 of HashTree.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - object to use as the key for the top level</dd>
<dt>Returns:</dt>
<dd>newly created <a href="HashTree.html" title="class in org.apache.jorphan.collections"><code>HashTree</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="createNewTree(java.util.Collection)">
<h3>createNewTree</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></span>&nbsp;<span class="element-name">createNewTree</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;values)</span></div>
<div class="block">Creates a new tree. This method exists to allow inheriting classes to
 generate the appropriate types of nodes. For instance, when a node is
 added, it's value is a HashTree. Rather than directly calling the
 HashTree() constructor, the createNewTree() method is called. Inheriting
 classes should override these methods and create the appropriate subclass
 of HashTree.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>values</code> - objects to be added to the new <a href="HashTree.html" title="class in org.apache.jorphan.collections"><code>HashTree</code></a></dd>
<dt>Returns:</dt>
<dd>newly created <a href="HashTree.html" title="class in org.apache.jorphan.collections"><code>HashTree</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getTree(java.util.Collection)">
<h3>getTree</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></span>&nbsp;<span class="element-name">getTree</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;treePath)</span></div>
<div class="block">Gets the HashTree object mapped to the last key in the SortedSet by
 recursing through the HashTree structure one key at a time.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>treePath</code> - Collection of keys</dd>
<dt>Returns:</dt>
<dd>HashTree at the end of the recursion</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="list()">
<h3>list</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/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;<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>&gt;</span>&nbsp;<span class="element-name">list</span>()</div>
<div class="block">Gets a Collection of all keys in the current HashTree node. If the
 HashTree represented a file system, this would be like getting a
 collection of all the files in the current folder.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>Set of all keys in this HashTree</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="list(java.lang.Object)">
<h3>list</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/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;</span>&nbsp;<span class="element-name">list</span><wbr><span class="parameters">(<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>&nbsp;key)</span></div>
<div class="block">Gets a Set of all keys in the HashTree mapped to the given key of the
 current HashTree object (in other words, one level down. If the HashTree
 represented a file system, this would like getting a list of all files in
 a sub-directory (of the current directory) specified by the key argument.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - key used to find HashTree to get list of</dd>
<dt>Returns:</dt>
<dd>Set of all keys in found HashTree.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="remove(java.lang.Object)">
<h3>remove</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></span>&nbsp;<span class="element-name">remove</span><wbr><span class="parameters">(<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>&nbsp;key)</span></div>
<div class="block">Removes the entire branch specified by the given key.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#remove(java.lang.Object)" title="class or interface in java.util" class="external-link">remove</a></code>&nbsp;in interface&nbsp;<code><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/Object.html" title="class or interface in java.lang" class="external-link">Object</a>,<wbr><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&gt;</code></dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#remove(java.lang.Object)" title="class or interface in java.util" class="external-link"><code>Map.remove(Object)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="list(java.lang.Object[])">
<h3>list</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/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;</span>&nbsp;<span class="element-name">list</span><wbr><span class="parameters">(<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>[]&nbsp;treePath)</span></div>
<div class="block">Recurses down into the HashTree structure using each subsequent key in the
 array of keys, and returns the Set of keys of the HashTree object at the
 end of the recursion. If the HashTree represented a file system, this
 would be like getting a list of all the files in a directory specified by
 the treePath, relative from the current directory.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>treePath</code> - Array of keys used to recurse into HashTree structure</dd>
<dt>Returns:</dt>
<dd>Set of all keys found in end HashTree</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="list(java.util.Collection)">
<h3>list</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/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;</span>&nbsp;<span class="element-name">list</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;treePath)</span></div>
<div class="block">Recurses down into the HashTree structure using each subsequent key in the
 List of keys, and returns the Set of keys of the HashTree object at the
 end of the recursion. If the HashTree represented a file system, this
 would be like getting a list of all the files in a directory specified by
 the treePath, relative from the current directory.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>treePath</code> - List of keys used to recurse into HashTree structure</dd>
<dt>Returns:</dt>
<dd>Set of all keys found in end HashTree</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="replaceKey(java.lang.Object,java.lang.Object)">
<h3>replaceKey</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">replaceKey</span><wbr><span class="parameters">(<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>&nbsp;currentKey,
 <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>&nbsp;newKey)</span></div>
<div class="block">Finds the given current key, and replaces it with the given new key. Any
 tree structure found under the original key is moved to the new key.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>currentKey</code> - name of the key to be replaced</dd>
<dd><code>newKey</code> - name of the new key</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getArray()">
<h3>getArray</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/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>[]</span>&nbsp;<span class="element-name">getArray</span>()</div>
<div class="block">Gets an array of all keys in the current HashTree node. If the HashTree
 represented a file system, this would be like getting an array of all the
 files in the current folder.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>array of all keys in this HashTree.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getArray(java.lang.Object)">
<h3>getArray</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/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>[]</span>&nbsp;<span class="element-name">getArray</span><wbr><span class="parameters">(<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>&nbsp;key)</span></div>
<div class="block">Gets an array of all keys in the HashTree mapped to the given key of the
 current HashTree object (in other words, one level down). If the HashTree
 represented a file system, this would like getting a list of all files in
 a sub-directory (of the current directory) specified by the key argument.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - key used to find HashTree to get list of</dd>
<dt>Returns:</dt>
<dd>array of all keys in found HashTree</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getArray(java.lang.Object[])">
<h3>getArray</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/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>[]</span>&nbsp;<span class="element-name">getArray</span><wbr><span class="parameters">(<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>[]&nbsp;treePath)</span></div>
<div class="block">Recurses down into the HashTree structure using each subsequent key in the
 array of keys, and returns an array of keys of the HashTree object at the
 end of the recursion. If the HashTree represented a file system, this
 would be like getting a list of all the files in a directory specified by
 the treePath, relative from the current directory.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>treePath</code> - array of keys used to recurse into HashTree structure</dd>
<dt>Returns:</dt>
<dd>array of all keys found in end HashTree</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getArray(java.util.Collection)">
<h3>getArray</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/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>[]</span>&nbsp;<span class="element-name">getArray</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;treePath)</span></div>
<div class="block">Recurses down into the HashTree structure using each subsequent key in the
 treePath argument, and returns an array of keys of the HashTree object at
 the end of the recursion. If the HashTree represented a file system, this
 would be like getting a list of all the files in a directory specified by
 the treePath, relative from the current directory.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>treePath</code> - list of keys used to recurse into HashTree structure</dd>
<dt>Returns:</dt>
<dd>array of all keys found in end HashTree</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getTreePath(java.util.Collection)">
<h3>getTreePath</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></span>&nbsp;<span class="element-name">getTreePath</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;treePath)</span></div>
</section>
</li>
<li>
<section class="detail" id="hashCode()">
<h3>hashCode</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">hashCode</span>()</div>
<div class="block">Returns a hashcode for this HashTree.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#hashCode()" title="class or interface in java.util" class="external-link">hashCode</a></code>&nbsp;in interface&nbsp;<code><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/Object.html" title="class or interface in java.lang" class="external-link">Object</a>,<wbr><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&gt;</code></dd>
<dt>Overrides:</dt>
<dd><code><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></code>&nbsp;in class&nbsp;<code><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></code></dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><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"><code>Object.hashCode()</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="equals(java.lang.Object)">
<h3>equals</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">equals</span><wbr><span class="parameters">(<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>&nbsp;o)</span></div>
<div class="block">Compares all objects in the tree and verifies that the two trees contain
 the same objects at the same tree levels. Returns true if they do, false
 otherwise.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#equals(java.lang.Object)" title="class or interface in java.util" class="external-link">equals</a></code>&nbsp;in interface&nbsp;<code><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/Object.html" title="class or interface in java.lang" class="external-link">Object</a>,<wbr><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&gt;</code></dd>
<dt>Overrides:</dt>
<dd><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></code>&nbsp;in class&nbsp;<code><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></code></dd>
<dt>Parameters:</dt>
<dd><code>o</code> - Object to be compared against</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><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"><code>Object.equals(Object)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="keySet()">
<h3>keySet</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/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<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>&gt;</span>&nbsp;<span class="element-name">keySet</span>()</div>
<div class="block">Returns a Set of all the keys in the top-level of this HashTree.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#keySet()" title="class or interface in java.util" class="external-link">keySet</a></code>&nbsp;in interface&nbsp;<code><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/Object.html" title="class or interface in java.lang" class="external-link">Object</a>,<wbr><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&gt;</code></dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#keySet()" title="class or interface in java.util" class="external-link"><code>Map.keySet()</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="search(java.lang.Object)">
<h3>search</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></span>&nbsp;<span class="element-name">search</span><wbr><span class="parameters">(<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>&nbsp;key)</span></div>
<div class="block">Searches the HashTree structure for the given key. If it finds the key,
 it returns the HashTree mapped to the key. If it finds nothing, it
 returns null.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - Key to search for</dd>
<dt>Returns:</dt>
<dd>HashTree mapped to key, if found, otherwise <code>null</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="size()">
<h3>size</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">size</span>()</div>
<div class="block">Returns the number of top-level entries in the HashTree.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#size()" title="class or interface in java.util" class="external-link">size</a></code>&nbsp;in interface&nbsp;<code><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/Object.html" title="class or interface in java.lang" class="external-link">Object</a>,<wbr><a href="HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&gt;</code></dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html#size()" title="class or interface in java.util" class="external-link"><code>Map.size()</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="traverse(org.apache.jorphan.collections.HashTreeTraverser)">
<h3>traverse</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">traverse</span><wbr><span class="parameters">(<a href="HashTreeTraverser.html" title="interface in org.apache.jorphan.collections">HashTreeTraverser</a>&nbsp;visitor)</span></div>
<div class="block">Allows any implementation of the HashTreeTraverser interface to easily
 traverse (depth-first) all the nodes of the HashTree. The Traverser
 implementation will be given notification of each node visited.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>visitor</code> - the visitor that wants to traverse the tree</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="HashTreeTraverser.html" title="interface in org.apache.jorphan.collections"><code>HashTreeTraverser</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="toString()">
<h3>toString</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/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">toString</span>()</div>
<div class="block">Generate a printable representation of the tree.</div>
<dl class="notes">
<dt>Overrides:</dt>
<dd><code><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></code>&nbsp;in class&nbsp;<code><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></code></dd>
<dt>Returns:</dt>
<dd>a representation of the tree</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright © 1998-2022 Apache Software Foundation. All Rights Reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
