<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>RelTraitSet (Apache Calcite 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.calcite.plan, class: RelTraitSet">
<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 Calcite</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>Nested&nbsp;|&nbsp;</li>
<li><a href="#field-summary">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method-summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&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.calcite.plan</a></div>
<h1 title="Class RelTraitSet" class="title">Class RelTraitSet</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">java.lang.Object</a>
<div class="inheritance"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractCollection.html" title="class or interface in java.util" class="external-link">java.util.AbstractCollection</a>&lt;E&gt;
<div class="inheritance"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractList.html" title="class or interface in java.util" class="external-link">java.util.AbstractList</a>&lt;<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&gt;
<div class="inheritance">org.apache.calcite.plan.RelTraitSet</div>
</div>
</div>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>All Implemented Interfaces:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&gt;</code>, <code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&gt;</code>, <code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&gt;</code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public final class </span><span class="element-name type-name-label">RelTraitSet</span>
<span class="extends-implements">extends <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractList.html" title="class or interface in java.util" class="external-link">AbstractList</a>&lt;<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&gt;</span></div>
<div class="block">RelTraitSet represents an ordered set of <a href="RelTrait.html" title="interface in org.apache.calcite.plan"><code>RelTrait</code></a>s.</div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- =========== FIELD SUMMARY =========== -->
<li>
<section class="field-summary" id="field-summary">
<h2>Field Summary</h2>
<div class="inherited-list">
<h3 id="fields-inherited-from-class-java.util.AbstractList">Fields inherited from class&nbsp;java.util.<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractList.html" title="class or interface in java.util" class="external-link">AbstractList</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractList.html#modCount" title="class or interface in java.util" class="external-link">modCount</a></code></div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab1" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab1', 3)" class="table-tab">Static Methods</button><button id="method-summary-table-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance Methods</button><button id="method-summary-table-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button></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>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#allSimple()" class="member-name-link">allSimple</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 whether there are any composite traits in this set.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#apply(org.apache.calcite.util.mapping.Mappings.TargetMapping)" class="member-name-link">apply</a><wbr>(<a href="../util/mapping/Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Applies a mapping to this traitSet.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>&lt;T extends <a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&gt;<br>T</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#canonize(T)" class="member-name-link">canonize</a><wbr>(T&nbsp;trait)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Converts a trait to canonical form.</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="#comprises(org.apache.calcite.plan.RelTrait...)" class="member-name-link">comprises</a><wbr>(<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>...&nbsp;relTraits)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns whether this trait set comprises precisely the list of given
 traits.</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="#contains(org.apache.calcite.plan.RelTrait)" class="member-name-link">contains</a><wbr>(<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&nbsp;trait)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns whether this trait set contains a given trait.</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="#containsIfApplicable(org.apache.calcite.plan.RelTrait)" class="member-name-link">containsIfApplicable</a><wbr>(<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&nbsp;trait)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns whether this trait set contains the given trait, or whether the
 trait is not present because its <a href="RelTraitDef.html" title="class in org.apache.calcite.plan"><code>RelTraitDef</code></a> is not enabled.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#createEmpty()" class="member-name-link">createEmpty</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an empty trait set.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>com.google.common.collect.ImmutableList&lt;<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</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="#difference(org.apache.calcite.plan.RelTraitSet)" class="member-name-link">difference</a><wbr>(<a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a>&nbsp;traitSet)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns a list of traits that are in <code>traitSet</code> but not in this
 RelTraitSet.</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>(@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;obj)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Compares two RelTraitSet objects for equality.</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="#equalsSansConvention(org.apache.calcite.plan.RelTraitSet)" class="member-name-link">equalsSansConvention</a><wbr>(<a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a>&nbsp;other)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns whether all the traits except <a href="Convention.html" title="interface in org.apache.calcite.plan"><code>Convention</code></a>
 equals with traits in <code>other</code> traitSet.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#get(int)" class="member-name-link">get</a><wbr>(int&nbsp;index)</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>&lt;T extends <a href="../rel/RelCollation.html" title="interface in org.apache.calcite.rel">RelCollation</a>&gt;<br>@Nullable T</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getCollation()" class="member-name-link">getCollation</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 <a href="../rel/RelCollation.html" title="interface in org.apache.calcite.rel"><code>RelCollation</code></a> trait defined by
 <a href="../rel/RelCollationTraitDef.html#INSTANCE"><code>RelCollationTraitDef.INSTANCE</code></a>, or null if the
 <a href="../rel/RelCollationTraitDef.html#INSTANCE"><code>RelCollationTraitDef.INSTANCE</code></a> is not registered
 in this traitSet.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>@Nullable <a href="Convention.html" title="interface in org.apache.calcite.plan">Convention</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getConvention()" class="member-name-link">getConvention</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 href="Convention.html" title="interface in org.apache.calcite.plan"><code>Convention</code></a> trait defined by
 <a href="ConventionTraitDef.html#INSTANCE"><code>ConventionTraitDef.INSTANCE</code></a>, or null if the
 <a href="ConventionTraitDef.html#INSTANCE"><code>ConventionTraitDef.INSTANCE</code></a> is not registered
 in this traitSet.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getDefault()" class="member-name-link">getDefault</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 a new traitSet with same traitDefs with
 current traitSet, but each trait is the default
 trait value.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getDefaultSansConvention()" class="member-name-link">getDefaultSansConvention</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 new traitSet with same traitDefs with
 current traitSet, but each trait except <a href="Convention.html" title="interface in org.apache.calcite.plan"><code>Convention</code></a>
 is the default trait value.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>&lt;T extends <a href="../rel/RelDistribution.html" title="interface in org.apache.calcite.rel">RelDistribution</a>&gt;<br>@Nullable T</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getDistribution()" class="member-name-link">getDistribution</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 <a href="../rel/RelDistribution.html" title="interface in org.apache.calcite.rel"><code>RelDistribution</code></a> trait defined by
 <a href="../rel/RelDistributionTraitDef.html#INSTANCE"><code>RelDistributionTraitDef.INSTANCE</code></a>, or null if the
 <a href="../rel/RelDistributionTraitDef.html#INSTANCE"><code>RelDistributionTraitDef.INSTANCE</code></a> is not registered
 in this traitSet.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getTrait(int)" class="member-name-link">getTrait</a><wbr>(int&nbsp;index)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Retrieves a RelTrait from the set.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>&lt;T extends <a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&gt;<br>@Nullable T</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getTrait(org.apache.calcite.plan.RelTraitDef)" class="member-name-link">getTrait</a><wbr>(<a href="RelTraitDef.html" title="class in org.apache.calcite.plan">RelTraitDef</a>&lt;T&gt;&nbsp;traitDef)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Retrieves a RelTrait of the given type from the set.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>&lt;E extends <a href="RelMultipleTrait.html" title="interface in org.apache.calcite.plan">RelMultipleTrait</a>&gt;<br><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getTraits(int)" class="member-name-link">getTraits</a><wbr>(int&nbsp;index)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Retrieves a list of traits from the set.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>&lt;T extends <a href="RelMultipleTrait.html" title="interface in org.apache.calcite.plan">RelMultipleTrait</a>&gt;<br>@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;T&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getTraits(org.apache.calcite.plan.RelTraitDef)" class="member-name-link">getTraits</a><wbr>(<a href="RelTraitDef.html" title="class in org.apache.calcite.plan">RelTraitDef</a>&lt;T&gt;&nbsp;traitDef)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Retrieves a list of traits of the given type from the set.</div>
</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">&nbsp;</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="#isDefault()" class="member-name-link">isDefault</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 whether all the traits are default trait value.</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="#isDefaultSansConvention()" class="member-name-link">isDefaultSansConvention</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 whether all the traits except <a href="Convention.html" title="interface in org.apache.calcite.plan"><code>Convention</code></a>
 are default trait value.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>&lt;T extends <a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&gt;<br>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#isEnabled(org.apache.calcite.plan.RelTraitDef)" class="member-name-link">isEnabled</a><wbr>(<a href="RelTraitDef.html" title="class in org.apache.calcite.plan">RelTraitDef</a>&lt;T&gt;&nbsp;traitDef)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns whether a given kind of trait is enabled.</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="#matches(org.apache.calcite.plan.RelTraitSet)" class="member-name-link">matches</a><wbr>(<a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a>&nbsp;that)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Compares two RelTraitSet objects to see if they match for the purposes of
 firing a rule.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#merge(org.apache.calcite.plan.RelTraitSet)" class="member-name-link">merge</a><wbr>(<a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a>&nbsp;additionalTraits)</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><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#plus(org.apache.calcite.plan.RelTrait)" class="member-name-link">plus</a><wbr>(<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&nbsp;trait)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns this trait set with a given trait added or overridden.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#plusAll(org.apache.calcite.plan.RelTrait%5B%5D)" class="member-name-link">plusAll</a><wbr>(<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>[]&nbsp;traits)</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><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#replace(int,org.apache.calcite.plan.RelTrait)" class="member-name-link">replace</a><wbr>(int&nbsp;index,
 <a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&nbsp;trait)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Replaces an existing RelTrait in the set.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>&lt;T extends <a href="RelMultipleTrait.html" title="interface in org.apache.calcite.plan">RelMultipleTrait</a>&gt;<br><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#replace(java.util.List)" class="member-name-link">replace</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;T&gt;&nbsp;traits)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Replaces the trait(s) of a given type with a list of traits of the same
 type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#replace(org.apache.calcite.plan.RelTrait)" class="member-name-link">replace</a><wbr>(<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&nbsp;trait)</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 trait set consisting of the current set plus a new trait.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>&lt;T extends <a href="RelMultipleTrait.html" title="interface in org.apache.calcite.plan">RelMultipleTrait</a>&gt;<br><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#replace(org.apache.calcite.plan.RelTraitDef,java.util.List)" class="member-name-link">replace</a><wbr>(<a href="RelTraitDef.html" title="class in org.apache.calcite.plan">RelTraitDef</a>&lt;T&gt;&nbsp;def,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;T&gt;&nbsp;traits)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Replaces the trait(s) of a given type with a list of traits of the same
 type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>&lt;T extends <a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&gt;<br><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#replaceIf(org.apache.calcite.plan.RelTraitDef,java.util.function.Supplier)" class="member-name-link">replaceIf</a><wbr>(<a href="RelTraitDef.html" title="class in org.apache.calcite.plan">RelTraitDef</a>&lt;T&gt;&nbsp;def,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/function/Supplier.html" title="class or interface in java.util.function" class="external-link">Supplier</a>&lt;? extends @Nullable T&gt;&nbsp;traitSupplier)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">If a given trait is enabled, replaces it by calling the given function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>&lt;T extends <a href="RelMultipleTrait.html" title="interface in org.apache.calcite.plan">RelMultipleTrait</a>&gt;<br><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#replaceIfs(org.apache.calcite.plan.RelTraitDef,java.util.function.Supplier)" class="member-name-link">replaceIfs</a><wbr>(<a href="RelTraitDef.html" title="class in org.apache.calcite.plan">RelTraitDef</a>&lt;T&gt;&nbsp;def,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/function/Supplier.html" title="class or interface in java.util.function" class="external-link">Supplier</a>&lt;? extends @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;T&gt;&gt;&nbsp;traitSupplier)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">If a given multiple trait is enabled, replaces it by calling the given
 function.</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="#satisfies(org.apache.calcite.plan.RelTraitSet)" class="member-name-link">satisfies</a><wbr>(<a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a>&nbsp;that)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns whether this trait set satisfies another trait set.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#simplify()" class="member-name-link">simplify</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 a trait set similar to this one but with all composite traits
 flattened.</div>
</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="#size()" class="member-name-link">size</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 the size of the RelTraitSet.</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/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.util.AbstractList">Methods inherited from class&nbsp;java.util.<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractList.html" title="class or interface in java.util" class="external-link">AbstractList</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractList.html#add(int,E)" title="class or interface in java.util" class="external-link">add</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractList.html#add(E)" title="class or interface in java.util" class="external-link">add</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractList.html#addAll(int,java.util.Collection)" title="class or interface in java.util" class="external-link">addAll</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractList.html#clear()" title="class or interface in java.util" class="external-link">clear</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractList.html#indexOf(java.lang.Object)" title="class or interface in java.util" class="external-link">indexOf</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractList.html#iterator()" title="class or interface in java.util" class="external-link">iterator</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractList.html#lastIndexOf(java.lang.Object)" title="class or interface in java.util" class="external-link">lastIndexOf</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractList.html#listIterator()" title="class or interface in java.util" class="external-link">listIterator</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractList.html#listIterator(int)" title="class or interface in java.util" class="external-link">listIterator</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractList.html#remove(int)" title="class or interface in java.util" class="external-link">remove</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractList.html#removeRange(int,int)" title="class or interface in java.util" class="external-link">removeRange</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractList.html#set(int,E)" title="class or interface in java.util" class="external-link">set</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractList.html#subList(int,int)" title="class or interface in java.util" class="external-link">subList</a></code></div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.util.AbstractCollection">Methods inherited from class&nbsp;java.util.<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractCollection.html" title="class or interface in java.util" class="external-link">AbstractCollection</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractCollection.html#addAll(java.util.Collection)" title="class or interface in java.util" class="external-link">addAll</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractCollection.html#contains(java.lang.Object)" title="class or interface in java.util" class="external-link">contains</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractCollection.html#containsAll(java.util.Collection)" title="class or interface in java.util" class="external-link">containsAll</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractCollection.html#isEmpty()" title="class or interface in java.util" class="external-link">isEmpty</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractCollection.html#remove(java.lang.Object)" title="class or interface in java.util" class="external-link">remove</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractCollection.html#removeAll(java.util.Collection)" title="class or interface in java.util" class="external-link">removeAll</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractCollection.html#retainAll(java.util.Collection)" title="class or interface in java.util" class="external-link">retainAll</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractCollection.html#toArray()" title="class or interface in java.util" class="external-link">toArray</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractCollection.html#toArray(T%5B%5D)" title="class or interface in java.util" class="external-link">toArray</a></code></div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.lang.Object">Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#clone()" title="class or interface in java.lang" class="external-link">clone</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#finalize()" title="class or interface in java.lang" class="external-link">finalize</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#getClass()" title="class or interface in java.lang" class="external-link">getClass</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#notify()" title="class or interface in java.lang" class="external-link">notify</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#notifyAll()" title="class or interface in java.lang" class="external-link">notifyAll</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#wait()" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#wait(long)" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/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.Collection">Methods inherited from interface&nbsp;java.util.<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html#parallelStream()" title="class or interface in java.util" class="external-link">parallelStream</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html#removeIf(java.util.function.Predicate)" title="class or interface in java.util" class="external-link">removeIf</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html#stream()" title="class or interface in java.util" class="external-link">stream</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html#toArray(java.util.function.IntFunction)" title="class or interface in java.util" class="external-link">toArray</a></code></div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.lang.Iterable">Methods inherited from interface&nbsp;java.lang.<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Iterable.html#forEach(java.util.function.Consumer)" title="class or interface in java.lang" class="external-link">forEach</a></code></div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.util.List">Methods inherited from interface&nbsp;java.util.<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html#addAll(java.util.Collection)" title="class or interface in java.util" class="external-link">addAll</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html#contains(java.lang.Object)" title="class or interface in java.util" class="external-link">contains</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html#containsAll(java.util.Collection)" title="class or interface in java.util" class="external-link">containsAll</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html#isEmpty()" title="class or interface in java.util" class="external-link">isEmpty</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html#remove(java.lang.Object)" title="class or interface in java.util" class="external-link">remove</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html#removeAll(java.util.Collection)" title="class or interface in java.util" class="external-link">removeAll</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html#replaceAll(java.util.function.UnaryOperator)" title="class or interface in java.util" class="external-link">replaceAll</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html#retainAll(java.util.Collection)" title="class or interface in java.util" class="external-link">retainAll</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html#sort(java.util.Comparator)" title="class or interface in java.util" class="external-link">sort</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html#spliterator()" title="class or interface in java.util" class="external-link">spliterator</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html#toArray()" title="class or interface in java.util" class="external-link">toArray</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html#toArray(T%5B%5D)" title="class or interface in java.util" class="external-link">toArray</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="createEmpty()">
<h3>createEmpty</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></span>&nbsp;<span class="element-name">createEmpty</span>()</div>
<div class="block">Creates an empty trait set.

 <p>It has a new cache, which will be shared by any trait set created from
 it. Thus each empty trait set is the start of a new ancestral line.</div>
</section>
</li>
<li>
<section class="detail" id="getTrait(int)">
<h3>getTrait</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a></span>&nbsp;<span class="element-name">getTrait</span><wbr><span class="parameters">(int&nbsp;index)</span></div>
<div class="block">Retrieves a RelTrait from the set.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>index</code> - 0-based index into ordered RelTraitSet</dd>
<dt>Returns:</dt>
<dd>the RelTrait</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/ArrayIndexOutOfBoundsException.html" title="class or interface in java.lang" class="external-link">ArrayIndexOutOfBoundsException</a></code> - if index greater than or equal to
                                        <a href="#size()"><code>size()</code></a> or less than 0.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getTraits(int)">
<h3>getTraits</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="type-parameters">&lt;E extends <a href="RelMultipleTrait.html" title="interface in org.apache.calcite.plan">RelMultipleTrait</a>&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</span>&nbsp;<span class="element-name">getTraits</span><wbr><span class="parameters">(int&nbsp;index)</span></div>
<div class="block">Retrieves a list of traits from the set.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>index</code> - 0-based index into ordered RelTraitSet</dd>
<dt>Returns:</dt>
<dd>the RelTrait</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/ArrayIndexOutOfBoundsException.html" title="class or interface in java.lang" class="external-link">ArrayIndexOutOfBoundsException</a></code> - if index greater than or equal to
                                        <a href="#size()"><code>size()</code></a> or less than 0.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="get(int)">
<h3>get</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a></span>&nbsp;<span class="element-name">get</span><wbr><span class="parameters">(int&nbsp;index)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html#get(int)" title="class or interface in java.util" class="external-link">get</a></code>&nbsp;in interface&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&gt;</code></dd>
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractList.html#get(int)" title="class or interface in java.util" class="external-link">get</a></code>&nbsp;in class&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractList.html" title="class or interface in java.util" class="external-link">AbstractList</a>&lt;<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&gt;</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isEnabled(org.apache.calcite.plan.RelTraitDef)">
<h3>isEnabled</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="type-parameters">&lt;T extends <a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&gt;</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isEnabled</span><wbr><span class="parameters">(<a href="RelTraitDef.html" title="class in org.apache.calcite.plan">RelTraitDef</a>&lt;T&gt;&nbsp;traitDef)</span></div>
<div class="block">Returns whether a given kind of trait is enabled.</div>
</section>
</li>
<li>
<section class="detail" id="getTrait(org.apache.calcite.plan.RelTraitDef)">
<h3>getTrait</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="type-parameters">&lt;T extends <a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&gt;</span>&nbsp;<span class="return-type">@Nullable T</span>&nbsp;<span class="element-name">getTrait</span><wbr><span class="parameters">(<a href="RelTraitDef.html" title="class in org.apache.calcite.plan">RelTraitDef</a>&lt;T&gt;&nbsp;traitDef)</span></div>
<div class="block">Retrieves a RelTrait of the given type from the set.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>traitDef</code> - the type of RelTrait to retrieve</dd>
<dt>Returns:</dt>
<dd>the RelTrait, or null if not found</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getTraits(org.apache.calcite.plan.RelTraitDef)">
<h3>getTraits</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="type-parameters">&lt;T extends <a href="RelMultipleTrait.html" title="interface in org.apache.calcite.plan">RelMultipleTrait</a>&gt;</span>
<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;T&gt;</span>&nbsp;<span class="element-name">getTraits</span><wbr><span class="parameters">(<a href="RelTraitDef.html" title="class in org.apache.calcite.plan">RelTraitDef</a>&lt;T&gt;&nbsp;traitDef)</span></div>
<div class="block">Retrieves a list of traits of the given type from the set.

 <p>Only valid for traits that support multiple entries. (E.g. collation.)</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>traitDef</code> - the type of RelTrait to retrieve</dd>
<dt>Returns:</dt>
<dd>the RelTrait, or null if not found</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="replace(int,org.apache.calcite.plan.RelTrait)">
<h3>replace</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></span>&nbsp;<span class="element-name">replace</span><wbr><span class="parameters">(int&nbsp;index,
 <a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&nbsp;trait)</span></div>
<div class="block">Replaces an existing RelTrait in the set.
 Returns a different trait set; does not modify this trait set.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>index</code> - 0-based index into ordered RelTraitSet</dd>
<dd><code>trait</code> - the new RelTrait</dd>
<dt>Returns:</dt>
<dd>the old RelTrait at the index</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="replace(org.apache.calcite.plan.RelTrait)">
<h3>replace</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></span>&nbsp;<span class="element-name">replace</span><wbr><span class="parameters">(<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&nbsp;trait)</span></div>
<div class="block">Returns a trait set consisting of the current set plus a new trait.

 <p>If the set does not contain a trait of the same <a href="RelTraitDef.html" title="class in org.apache.calcite.plan"><code>RelTraitDef</code></a>,
 the trait is ignored, and this trait set is returned.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>trait</code> - the new trait</dd>
<dt>Returns:</dt>
<dd>New set</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="#plus(org.apache.calcite.plan.RelTrait)"><code>plus(RelTrait)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="replace(java.util.List)">
<h3>replace</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="type-parameters">&lt;T extends <a href="RelMultipleTrait.html" title="interface in org.apache.calcite.plan">RelMultipleTrait</a>&gt;</span>&nbsp;<span class="return-type"><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></span>&nbsp;<span class="element-name">replace</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;T&gt;&nbsp;traits)</span></div>
<div class="block">Replaces the trait(s) of a given type with a list of traits of the same
 type.

 <p>The list must not be empty, and all traits must be of the same type.</div>
</section>
</li>
<li>
<section class="detail" id="replace(org.apache.calcite.plan.RelTraitDef,java.util.List)">
<h3>replace</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="type-parameters">&lt;T extends <a href="RelMultipleTrait.html" title="interface in org.apache.calcite.plan">RelMultipleTrait</a>&gt;</span>&nbsp;<span class="return-type"><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></span>&nbsp;<span class="element-name">replace</span><wbr><span class="parameters">(<a href="RelTraitDef.html" title="class in org.apache.calcite.plan">RelTraitDef</a>&lt;T&gt;&nbsp;def,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;T&gt;&nbsp;traits)</span></div>
<div class="block">Replaces the trait(s) of a given type with a list of traits of the same
 type.

 <p>The list must not be empty, and all traits must be of the same type.</div>
</section>
</li>
<li>
<section class="detail" id="replaceIfs(org.apache.calcite.plan.RelTraitDef,java.util.function.Supplier)">
<h3>replaceIfs</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="type-parameters">&lt;T extends <a href="RelMultipleTrait.html" title="interface in org.apache.calcite.plan">RelMultipleTrait</a>&gt;</span>&nbsp;<span class="return-type"><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></span>&nbsp;<span class="element-name">replaceIfs</span><wbr><span class="parameters">(<a href="RelTraitDef.html" title="class in org.apache.calcite.plan">RelTraitDef</a>&lt;T&gt;&nbsp;def,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/function/Supplier.html" title="class or interface in java.util.function" class="external-link">Supplier</a>&lt;? extends @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;T&gt;&gt;&nbsp;traitSupplier)</span></div>
<div class="block">If a given multiple trait is enabled, replaces it by calling the given
 function.</div>
</section>
</li>
<li>
<section class="detail" id="replaceIf(org.apache.calcite.plan.RelTraitDef,java.util.function.Supplier)">
<h3>replaceIf</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="type-parameters">&lt;T extends <a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&gt;</span>&nbsp;<span class="return-type"><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></span>&nbsp;<span class="element-name">replaceIf</span><wbr><span class="parameters">(<a href="RelTraitDef.html" title="class in org.apache.calcite.plan">RelTraitDef</a>&lt;T&gt;&nbsp;def,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/function/Supplier.html" title="class or interface in java.util.function" class="external-link">Supplier</a>&lt;? extends @Nullable T&gt;&nbsp;traitSupplier)</span></div>
<div class="block">If a given trait is enabled, replaces it by calling the given function.</div>
</section>
</li>
<li>
<section class="detail" id="apply(org.apache.calcite.util.mapping.Mappings.TargetMapping)">
<h3>apply</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></span>&nbsp;<span class="element-name">apply</span><wbr><span class="parameters">(<a href="../util/mapping/Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping)</span></div>
<div class="block">Applies a mapping to this traitSet.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>mapping</code> - Mapping</dd>
<dt>Returns:</dt>
<dd>traitSet with mapping applied</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isDefault()">
<h3>isDefault</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isDefault</span>()</div>
<div class="block">Returns whether all the traits are default trait value.</div>
</section>
</li>
<li>
<section class="detail" id="isDefaultSansConvention()">
<h3>isDefaultSansConvention</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isDefaultSansConvention</span>()</div>
<div class="block">Returns whether all the traits except <a href="Convention.html" title="interface in org.apache.calcite.plan"><code>Convention</code></a>
 are default trait value.</div>
</section>
</li>
<li>
<section class="detail" id="equalsSansConvention(org.apache.calcite.plan.RelTraitSet)">
<h3>equalsSansConvention</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">equalsSansConvention</span><wbr><span class="parameters">(<a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a>&nbsp;other)</span></div>
<div class="block">Returns whether all the traits except <a href="Convention.html" title="interface in org.apache.calcite.plan"><code>Convention</code></a>
 equals with traits in <code>other</code> traitSet.</div>
</section>
</li>
<li>
<section class="detail" id="getDefault()">
<h3>getDefault</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></span>&nbsp;<span class="element-name">getDefault</span>()</div>
<div class="block">Returns a new traitSet with same traitDefs with
 current traitSet, but each trait is the default
 trait value.</div>
</section>
</li>
<li>
<section class="detail" id="getDefaultSansConvention()">
<h3>getDefaultSansConvention</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></span>&nbsp;<span class="element-name">getDefaultSansConvention</span>()</div>
<div class="block">Returns a new traitSet with same traitDefs with
 current traitSet, but each trait except <a href="Convention.html" title="interface in org.apache.calcite.plan"><code>Convention</code></a>
 is the default trait value. <a href="Convention.html" title="interface in org.apache.calcite.plan"><code>Convention</code></a> trait
 remains the same with current traitSet.</div>
</section>
</li>
<li>
<section class="detail" id="getConvention()">
<h3>getConvention</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">@Nullable <a href="Convention.html" title="interface in org.apache.calcite.plan">Convention</a></span>&nbsp;<span class="element-name">getConvention</span>()</div>
<div class="block">Returns <a href="Convention.html" title="interface in org.apache.calcite.plan"><code>Convention</code></a> trait defined by
 <a href="ConventionTraitDef.html#INSTANCE"><code>ConventionTraitDef.INSTANCE</code></a>, or null if the
 <a href="ConventionTraitDef.html#INSTANCE"><code>ConventionTraitDef.INSTANCE</code></a> is not registered
 in this traitSet.</div>
</section>
</li>
<li>
<section class="detail" id="getDistribution()">
<h3>getDistribution</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="type-parameters">&lt;T extends <a href="../rel/RelDistribution.html" title="interface in org.apache.calcite.rel">RelDistribution</a>&gt;</span>&nbsp;<span class="return-type">@Nullable T</span>&nbsp;<span class="element-name">getDistribution</span>()</div>
<div class="block">Returns <a href="../rel/RelDistribution.html" title="interface in org.apache.calcite.rel"><code>RelDistribution</code></a> trait defined by
 <a href="../rel/RelDistributionTraitDef.html#INSTANCE"><code>RelDistributionTraitDef.INSTANCE</code></a>, or null if the
 <a href="../rel/RelDistributionTraitDef.html#INSTANCE"><code>RelDistributionTraitDef.INSTANCE</code></a> is not registered
 in this traitSet.</div>
</section>
</li>
<li>
<section class="detail" id="getCollation()">
<h3>getCollation</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="type-parameters">&lt;T extends <a href="../rel/RelCollation.html" title="interface in org.apache.calcite.rel">RelCollation</a>&gt;</span>&nbsp;<span class="return-type">@Nullable T</span>&nbsp;<span class="element-name">getCollation</span>()</div>
<div class="block">Returns <a href="../rel/RelCollation.html" title="interface in org.apache.calcite.rel"><code>RelCollation</code></a> trait defined by
 <a href="../rel/RelCollationTraitDef.html#INSTANCE"><code>RelCollationTraitDef.INSTANCE</code></a>, or null if the
 <a href="../rel/RelCollationTraitDef.html#INSTANCE"><code>RelCollationTraitDef.INSTANCE</code></a> is not registered
 in this traitSet.</div>
</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 size of the RelTraitSet.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.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/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&gt;</code></dd>
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.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/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&gt;</code></dd>
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractCollection.html#size()" title="class or interface in java.util" class="external-link">size</a></code>&nbsp;in class&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractCollection.html" title="class or interface in java.util" class="external-link">AbstractCollection</a>&lt;<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the size of the RelTraitSet.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="canonize(T)">
<h3 id="canonize(org.apache.calcite.plan.RelTrait)">canonize</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="type-parameters">&lt;T extends <a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&gt;</span>&nbsp;<span class="return-type">T</span>&nbsp;<span class="element-name">canonize</span><wbr><span class="parameters">(T&nbsp;trait)</span></div>
<div class="block">Converts a trait to canonical form.

 <p>After canonization, t1.equals(t2) if and only if t1 == t2.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>trait</code> - Trait</dd>
<dt>Returns:</dt>
<dd>Trait in canonical form</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">(@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;obj)</span></div>
<div class="block">Compares two RelTraitSet objects for equality.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.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/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&gt;</code></dd>
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.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/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&gt;</code></dd>
<dt>Overrides:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractList.html#equals(java.lang.Object)" title="class or interface in java.util" class="external-link">equals</a></code>&nbsp;in class&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractList.html" title="class or interface in java.util" class="external-link">AbstractList</a>&lt;<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&gt;</code></dd>
<dt>Parameters:</dt>
<dd><code>obj</code> - another RelTraitSet</dd>
<dt>Returns:</dt>
<dd>true if traits are equal and in the same order, false otherwise</dd>
</dl>
</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>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.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/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&gt;</code></dd>
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.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/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&gt;</code></dd>
<dt>Overrides:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractList.html#hashCode()" title="class or interface in java.util" class="external-link">hashCode</a></code>&nbsp;in class&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractList.html" title="class or interface in java.util" class="external-link">AbstractList</a>&lt;<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&gt;</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="satisfies(org.apache.calcite.plan.RelTraitSet)">
<h3>satisfies</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">satisfies</span><wbr><span class="parameters">(<a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a>&nbsp;that)</span></div>
<div class="block">Returns whether this trait set satisfies another trait set.

 <p>For that to happen, each trait satisfies the corresponding trait in the
 other set. In particular, each trait set satisfies itself, because each
 trait subsumes itself.

 <p>Intuitively, if a relational expression is needed that has trait set
 S (A, B), and trait set S1 (A1, B1) subsumes S, then any relational
 expression R in S1 meets that need.

 <p>For example, if we need a relational expression that has
 trait set S = {enumerable convention, sorted on [C1 asc]}, and R
 has {enumerable convention, sorted on [C3], [C1, C2]}. R has two
 sort keys, but one them [C1, C2] satisfies S [C1], and that is enough.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>that</code> - another RelTraitSet</dd>
<dt>Returns:</dt>
<dd>whether this trait set satisfies other trait set</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="RelTrait.html#satisfies(org.apache.calcite.plan.RelTrait)"><code>RelTrait.satisfies(RelTrait)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="matches(org.apache.calcite.plan.RelTraitSet)">
<h3>matches</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">matches</span><wbr><span class="parameters">(<a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a>&nbsp;that)</span></div>
<div class="block">Compares two RelTraitSet objects to see if they match for the purposes of
 firing a rule. A null RelTrait within a RelTraitSet indicates a wildcard:
 any RelTrait in the other RelTraitSet will match. If one RelTraitSet is
 smaller than the other, comparison stops when the last RelTrait from the
 smaller set has been examined and the remaining RelTraits in the larger
 set are assumed to match.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>that</code> - another RelTraitSet</dd>
<dt>Returns:</dt>
<dd>true if the RelTraitSets match, false otherwise</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="contains(org.apache.calcite.plan.RelTrait)">
<h3>contains</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">contains</span><wbr><span class="parameters">(<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&nbsp;trait)</span></div>
<div class="block">Returns whether this trait set contains a given trait.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>trait</code> - Sought trait</dd>
<dt>Returns:</dt>
<dd>Whether set contains given trait</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="containsIfApplicable(org.apache.calcite.plan.RelTrait)">
<h3>containsIfApplicable</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">containsIfApplicable</span><wbr><span class="parameters">(<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&nbsp;trait)</span></div>
<div class="block">Returns whether this trait set contains the given trait, or whether the
 trait is not present because its <a href="RelTraitDef.html" title="class in org.apache.calcite.plan"><code>RelTraitDef</code></a> is not enabled.
 Returns false if another trait of the same <code>RelTraitDef</code> is
 present.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>trait</code> - Trait</dd>
<dt>Returns:</dt>
<dd>Whether trait is present, or is absent because disabled</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="comprises(org.apache.calcite.plan.RelTrait...)">
<h3>comprises</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">comprises</span><wbr><span class="parameters">(<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>...&nbsp;relTraits)</span></div>
<div class="block">Returns whether this trait set comprises precisely the list of given
 traits.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>relTraits</code> - Traits</dd>
<dt>Returns:</dt>
<dd>Whether this trait set's traits are the same as the argument</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/en/java/javase/17/docs/api/java.base/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>
<dl class="notes">
<dt>Overrides:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractCollection.html#toString()" title="class or interface in java.util" class="external-link">toString</a></code>&nbsp;in class&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/AbstractCollection.html" title="class or interface in java.util" class="external-link">AbstractCollection</a>&lt;<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&gt;</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="plus(org.apache.calcite.plan.RelTrait)">
<h3>plus</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></span>&nbsp;<span class="element-name">plus</span><wbr><span class="parameters">(<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&nbsp;trait)</span></div>
<div class="block">Returns this trait set with a given trait added or overridden. Does not
 modify this trait set.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>trait</code> - Trait</dd>
<dt>Returns:</dt>
<dd>Trait set with given trait</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="plusAll(org.apache.calcite.plan.RelTrait[])">
<h3>plusAll</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></span>&nbsp;<span class="element-name">plusAll</span><wbr><span class="parameters">(<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>[]&nbsp;traits)</span></div>
</section>
</li>
<li>
<section class="detail" id="merge(org.apache.calcite.plan.RelTraitSet)">
<h3>merge</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></span>&nbsp;<span class="element-name">merge</span><wbr><span class="parameters">(<a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a>&nbsp;additionalTraits)</span></div>
</section>
</li>
<li>
<section class="detail" id="difference(org.apache.calcite.plan.RelTraitSet)">
<h3>difference</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">com.google.common.collect.ImmutableList&lt;<a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&gt;</span>&nbsp;<span class="element-name">difference</span><wbr><span class="parameters">(<a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a>&nbsp;traitSet)</span></div>
<div class="block">Returns a list of traits that are in <code>traitSet</code> but not in this
 RelTraitSet.</div>
</section>
</li>
<li>
<section class="detail" id="allSimple()">
<h3>allSimple</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">allSimple</span>()</div>
<div class="block">Returns whether there are any composite traits in this set.</div>
</section>
</li>
<li>
<section class="detail" id="simplify()">
<h3>simplify</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="RelTraitSet.html" title="class in org.apache.calcite.plan">RelTraitSet</a></span>&nbsp;<span class="element-name">simplify</span>()</div>
<div class="block">Returns a trait set similar to this one but with all composite traits
 flattened.</div>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright &copy; 2012-2023 Apache Software Foundation. All Rights Reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
