<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>Mappings (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.util.mapping, class: Mappings">
<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><a href="#nested-class-summary">Nested</a>&nbsp;|&nbsp;</li>
<li>Field&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.util.mapping</a></div>
<h1 title="Class Mappings" class="title">Class Mappings</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">org.apache.calcite.util.mapping.Mappings</div>
</div>
<section class="class-description" id="class-description">
<hr>
<div class="type-signature"><span class="modifiers">public abstract class </span><span class="element-name type-name-label">Mappings</span>
<span class="extends-implements">extends <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></span></div>
<div class="block">Utility functions related to mappings.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="MappingType.html" title="enum in org.apache.calcite.util.mapping"><code>MappingType</code></a></li>
<li><a href="Mapping.html" title="interface in org.apache.calcite.util.mapping"><code>Mapping</code></a></li>
<li><a href="../Permutation.html" title="class in org.apache.calcite.util"><code>Permutation</code></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="caption"><span>Nested Classes</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Class</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="Mappings.AbstractMapping.html" class="type-name-link" title="class in org.apache.calcite.util.mapping">Mappings.AbstractMapping</a></code></div>
<div class="col-last even-row-color">
<div class="block">Abstract implementation of <a href="Mapping.html" title="interface in org.apache.calcite.util.mapping"><code>Mapping</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code>static interface&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="Mappings.CoreMapping.html" class="type-name-link" title="interface in org.apache.calcite.util.mapping">Mappings.CoreMapping</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Core interface of all mappings.</div>
</div>
<div class="col-first even-row-color"><code>static class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="Mappings.FiniteAbstractMapping.html" class="type-name-link" title="class in org.apache.calcite.util.mapping">Mappings.FiniteAbstractMapping</a></code></div>
<div class="col-last even-row-color">
<div class="block">Abstract implementation of mapping where both source and target
 domains are finite.</div>
</div>
<div class="col-first odd-row-color"><code>static interface&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="Mappings.FunctionMapping.html" class="type-name-link" title="interface in org.apache.calcite.util.mapping">Mappings.FunctionMapping</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Mapping where every source has a target.</div>
</div>
<div class="col-first even-row-color"><code>static class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="Mappings.IdentityMapping.html" class="type-name-link" title="class in org.apache.calcite.util.mapping">Mappings.IdentityMapping</a></code></div>
<div class="col-last even-row-color">
<div class="block">The identity mapping, of a given size, or infinite.</div>
</div>
<div class="col-first odd-row-color"><code>static class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="Mappings.NoElementException.html" class="type-name-link" title="class in org.apache.calcite.util.mapping">Mappings.NoElementException</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Thrown when a mapping is expected to return one element but returns none.</div>
</div>
<div class="col-first even-row-color"><code>static class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="Mappings.OverridingSourceMapping.html" class="type-name-link" title="class in org.apache.calcite.util.mapping">Mappings.OverridingSourceMapping</a></code></div>
<div class="col-last even-row-color">
<div class="block">Source mapping that returns the same result as a parent
 <a href="Mappings.SourceMapping.html" title="interface in org.apache.calcite.util.mapping"><code>Mappings.SourceMapping</code></a> except for specific overriding elements.</div>
</div>
<div class="col-first odd-row-color"><code>static class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="Mappings.OverridingTargetMapping.html" class="type-name-link" title="class in org.apache.calcite.util.mapping">Mappings.OverridingTargetMapping</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Target mapping that returns the same result as a parent
 <a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping"><code>Mappings.TargetMapping</code></a> except for specific overriding elements.</div>
</div>
<div class="col-first even-row-color"><code>static class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="Mappings.PartialMapping.html" class="type-name-link" title="class in org.apache.calcite.util.mapping">Mappings.PartialMapping</a></code></div>
<div class="col-last even-row-color">
<div class="block">A mapping where a source has at most one target, and every target has at
 most one source.</div>
</div>
<div class="col-first odd-row-color"><code>static interface&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="Mappings.SourceMapping.html" class="type-name-link" title="interface in org.apache.calcite.util.mapping">Mappings.SourceMapping</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Mapping suitable for sourcing columns.</div>
</div>
<div class="col-first even-row-color"><code>static interface&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="Mappings.TargetMapping.html" class="type-name-link" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></code></div>
<div class="col-last even-row-color">
<div class="block">Mapping suitable for mapping columns to a target.</div>
</div>
<div class="col-first odd-row-color"><code>static class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="Mappings.TooManyElementsException.html" class="type-name-link" title="class in org.apache.calcite.util.mapping">Mappings.TooManyElementsException</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Thrown when a mapping is expected to return one element but returns
 several.</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-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-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-tab1 method-summary-table-tab4"><code>static <a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#append(org.apache.calcite.util.mapping.Mappings.TargetMapping,org.apache.calcite.util.mapping.Mappings.TargetMapping)" class="member-name-link">append</a><wbr>(<a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping0,
 <a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a mapping by appending two mappings.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/BitSet.html" title="class or interface in java.util" class="external-link">BitSet</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#apply(org.apache.calcite.util.mapping.Mapping,java.util.BitSet)" class="member-name-link">apply</a><wbr>(<a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/BitSet.html" title="class or interface in java.util" class="external-link">BitSet</a>&nbsp;bitSet)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Applies a mapping to a BitSet.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T&gt;&nbsp;<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 even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#apply(org.apache.calcite.util.mapping.Mapping,java.util.List)" class="member-name-link">apply</a><wbr>(<a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping,
 <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;list)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Applies a mapping to a list.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#apply(org.apache.calcite.util.mapping.Mapping,org.apache.calcite.util.ImmutableBitSet)" class="member-name-link">apply</a><wbr>(<a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping,
 <a href="../ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;bitSet)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Applies a mapping to an <code>ImmutableBitSet</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#apply(org.apache.calcite.util.mapping.Mappings.TargetMapping,int)" class="member-name-link">apply</a><wbr>(<a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping,
 int&nbsp;i)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Applies a mapping to an optional integer, returning an optional
 result.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static com.google.common.collect.ImmutableList&lt;<a href="../ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#apply2(org.apache.calcite.util.mapping.Mapping,java.lang.Iterable)" class="member-name-link">apply2</a><wbr>(<a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping,
 <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="../ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&gt;&nbsp;bitSets)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Applies a mapping to a collection of <code>ImmutableBitSet</code>s.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/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="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#apply2(org.apache.calcite.util.mapping.Mapping,java.util.List)" class="member-name-link">apply2</a><wbr>(<a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping,
 <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="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;list)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T&gt;&nbsp;<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-tab1 method-summary-table-tab4"><code><a href="#apply3(org.apache.calcite.util.mapping.Mapping,java.util.List)" class="member-name-link">apply3</a><wbr>(<a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping,
 <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;list)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a view of a list, permuting according to a mapping.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/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;@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#asList(org.apache.calcite.util.mapping.Mappings.TargetMapping)" class="member-name-link">asList</a><wbr>(<a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a mapping as a list such that <code>list.get(source)</code> is
 <code>mapping.getTarget(source)</code> and <code>list.size()</code> is
 <code>mapping.getSourceCount()</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/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="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#asListNonNull(org.apache.calcite.util.mapping.Mappings.TargetMapping)" class="member-name-link">asListNonNull</a><wbr>(<a href="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-tab1 method-summary-table-tab4">
<div class="block">Returns a mapping as a list such that <code>list.get(source)</code> is
 <code>mapping.getTarget(source)</code> and <code>list.size()</code> is
 <code>mapping.getSourceCount()</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#bijection(java.util.List)" class="member-name-link">bijection</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;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;targets)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a bijection.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#bijection(java.util.Map)" class="member-name-link">bijection</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;targets)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a bijection.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#create(org.apache.calcite.util.mapping.MappingType,int,int)" class="member-name-link">create</a><wbr>(<a href="MappingType.html" title="enum in org.apache.calcite.util.mapping">MappingType</a>&nbsp;mappingType,
 int&nbsp;sourceCount,
 int&nbsp;targetCount)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a mapping with required properties.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Mappings.IdentityMapping.html" title="class in org.apache.calcite.util.mapping">Mappings.IdentityMapping</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#createIdentity(int)" class="member-name-link">createIdentity</a><wbr>(int&nbsp;fieldCount)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates the identity mapping.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#createShiftMapping(int,int...)" class="member-name-link">createShiftMapping</a><wbr>(int&nbsp;sourceCount,
 int...&nbsp;ints)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a mapping that consists of a set of contiguous ranges.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#divide(org.apache.calcite.util.mapping.Mapping,org.apache.calcite.util.mapping.Mapping)" class="member-name-link">divide</a><wbr>(<a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping1,
 <a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping2)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Divides one mapping by another.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/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="IntPair.html" title="class in org.apache.calcite.util.mapping">IntPair</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#invert(java.lang.Iterable)" class="member-name-link">invert</a><wbr>(<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="IntPair.html" title="class in org.apache.calcite.util.mapping">IntPair</a>&gt;&nbsp;pairs)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Inverts an <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"><code>Iterable</code></a> over
 <a href="IntPair.html" title="class in org.apache.calcite.util.mapping"><code>IntPair</code></a>s.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Iterator.html" title="class or interface in java.util" class="external-link">Iterator</a>&lt;<a href="IntPair.html" title="class in org.apache.calcite.util.mapping">IntPair</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#invert(java.util.Iterator)" class="member-name-link">invert</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Iterator.html" title="class or interface in java.util" class="external-link">Iterator</a>&lt;<a href="IntPair.html" title="class in org.apache.calcite.util.mapping">IntPair</a>&gt;&nbsp;pairs)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Inverts an <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Iterator.html" title="class or interface in java.util" class="external-link"><code>Iterator</code></a> over
 <a href="IntPair.html" title="class in org.apache.calcite.util.mapping"><code>IntPair</code></a>s.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#invert(org.apache.calcite.util.mapping.Mapping)" class="member-name-link">invert</a><wbr>(<a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a mapping to its inverse.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isIdentity(java.util.List,int)" class="member-name-link">isIdentity</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;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;list,
 int&nbsp;count)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether a list of integers is the identity mapping
 [0, ..., n - 1].</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isIdentity(org.apache.calcite.util.mapping.Mappings.TargetMapping)" class="member-name-link">isIdentity</a><wbr>(<a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether a mapping is the identity.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#keepsOrdering(org.apache.calcite.util.mapping.Mappings.TargetMapping)" class="member-name-link">keepsOrdering</a><wbr>(<a href="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-tab1 method-summary-table-tab4">
<div class="block">Returns whether a mapping keeps order.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#merge(org.apache.calcite.util.mapping.Mappings.TargetMapping,org.apache.calcite.util.mapping.Mappings.TargetMapping)" class="member-name-link">merge</a><wbr>(<a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping0,
 <a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a mapping by merging two mappings.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#multiply(org.apache.calcite.util.mapping.Mapping,org.apache.calcite.util.mapping.Mapping)" class="member-name-link">multiply</a><wbr>(<a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping1,
 <a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping2)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Multiplies one mapping by another.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#offset(org.apache.calcite.util.mapping.Mappings.TargetMapping,int,int)" class="member-name-link">offset</a><wbr>(<a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping,
 int&nbsp;offset,
 int&nbsp;sourceCount)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a mapping that shifts a given mapping's source and target by a
 given offset.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#offsetSource(org.apache.calcite.util.mapping.Mappings.TargetMapping,int)" class="member-name-link">offsetSource</a><wbr>(<a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping,
 int&nbsp;offset)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a mapping that shifts a given mapping's source by a given
 offset, incrementing the number of sources by the minimum possible.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#offsetSource(org.apache.calcite.util.mapping.Mappings.TargetMapping,int,int)" class="member-name-link">offsetSource</a><wbr>(<a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping,
 int&nbsp;offset,
 int&nbsp;sourceCount)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a mapping that shifts a given mapping's source by a given
 offset.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#offsetTarget(org.apache.calcite.util.mapping.Mappings.TargetMapping,int)" class="member-name-link">offsetTarget</a><wbr>(<a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping,
 int&nbsp;offset)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a mapping that shifts a given mapping's target by a given
 offset, incrementing the number of targets by the minimum possible.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#offsetTarget(org.apache.calcite.util.mapping.Mappings.TargetMapping,int,int)" class="member-name-link">offsetTarget</a><wbr>(<a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping,
 int&nbsp;offset,
 int&nbsp;targetCount)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a mapping that shifts a given mapping's target by a given
 offset.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T&gt;&nbsp;<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-tab1 method-summary-table-tab4"><code><a href="#permute(java.util.List,org.apache.calcite.util.mapping.Mappings.TargetMapping)" class="member-name-link">permute</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;list,
 <a href="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-tab1 method-summary-table-tab4">
<div class="block">Creates a view of a list, permuting according to a target mapping.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#source(java.util.List,int)" class="member-name-link">source</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;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;targets,
 int&nbsp;targetCount)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#target(java.lang.Iterable,int,int)" class="member-name-link">target</a><wbr>(<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="IntPair.html" title="class in org.apache.calcite.util.mapping">IntPair</a>&gt;&nbsp;pairs,
 int&nbsp;sourceCount,
 int&nbsp;targetCount)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#target(java.util.function.IntFunction,int,int)" class="member-name-link">target</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/function/IntFunction.html" title="class or interface in java.util.function" class="external-link">IntFunction</a>&lt;? extends @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;function,
 int&nbsp;sourceCount,
 int&nbsp;targetCount)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#target(java.util.List,int)" class="member-name-link">target</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;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;sources,
 int&nbsp;sourceCount)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#target(java.util.Map,int,int)" class="member-name-link">target</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;map,
 int&nbsp;sourceCount,
 int&nbsp;targetCount)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link"><code>Map</code></a> of integers to a <a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping"><code>Mappings.TargetMapping</code></a>.</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/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#equals(java.lang.Object)" title="class or interface in java.lang" class="external-link">equals</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#hashCode()" title="class or interface in java.lang" class="external-link">hashCode</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#toString()" title="class or interface in java.lang" class="external-link">toString</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>
</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="create(org.apache.calcite.util.mapping.MappingType,int,int)">
<h3>create</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a></span>&nbsp;<span class="element-name">create</span><wbr><span class="parameters">(<a href="MappingType.html" title="enum in org.apache.calcite.util.mapping">MappingType</a>&nbsp;mappingType,
 int&nbsp;sourceCount,
 int&nbsp;targetCount)</span></div>
<div class="block">Creates a mapping with required properties.</div>
</section>
</li>
<li>
<section class="detail" id="createIdentity(int)">
<h3>createIdentity</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Mappings.IdentityMapping.html" title="class in org.apache.calcite.util.mapping">Mappings.IdentityMapping</a></span>&nbsp;<span class="element-name">createIdentity</span><wbr><span class="parameters">(int&nbsp;fieldCount)</span></div>
<div class="block">Creates the identity mapping.

 <p>For example, <code>createIdentity(2)</code> returns the mapping
 {0:0, 1:1, 2:2}.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>fieldCount</code> - Number of sources/targets</dd>
<dt>Returns:</dt>
<dd>Identity mapping</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="invert(org.apache.calcite.util.mapping.Mapping)">
<h3>invert</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a></span>&nbsp;<span class="element-name">invert</span><wbr><span class="parameters">(<a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping)</span></div>
<div class="block">Converts a mapping to its inverse.</div>
</section>
</li>
<li>
<section class="detail" id="divide(org.apache.calcite.util.mapping.Mapping,org.apache.calcite.util.mapping.Mapping)">
<h3>divide</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a></span>&nbsp;<span class="element-name">divide</span><wbr><span class="parameters">(<a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping1,
 <a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping2)</span></div>
<div class="block">Divides one mapping by another.

 <p><code>divide(A, B)</code> returns a mapping C such that B . C (the mapping
 B followed by the mapping C) is equivalent to A.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>mapping1</code> - First mapping</dd>
<dd><code>mapping2</code> - Second mapping</dd>
<dt>Returns:</dt>
<dd>Mapping mapping3 such that mapping1 = mapping2 . mapping3</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="multiply(org.apache.calcite.util.mapping.Mapping,org.apache.calcite.util.mapping.Mapping)">
<h3>multiply</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a></span>&nbsp;<span class="element-name">multiply</span><wbr><span class="parameters">(<a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping1,
 <a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping2)</span></div>
<div class="block">Multiplies one mapping by another.

 <p><code>multiply(A, B)</code> returns a mapping C such that A . B (the mapping
 A followed by the mapping B) is equivalent to C.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>mapping1</code> - First mapping</dd>
<dd><code>mapping2</code> - Second mapping</dd>
<dt>Returns:</dt>
<dd>Mapping mapping3 such that mapping1 = mapping2 . mapping3</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="apply(org.apache.calcite.util.mapping.Mapping,java.util.BitSet)">
<h3>apply</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/BitSet.html" title="class or interface in java.util" class="external-link">BitSet</a></span>&nbsp;<span class="element-name">apply</span><wbr><span class="parameters">(<a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/BitSet.html" title="class or interface in java.util" class="external-link">BitSet</a>&nbsp;bitSet)</span></div>
<div class="block">Applies a mapping to a BitSet.

 <p>If the mapping does not affect the bit set, returns the original.
 Never changes the original.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>mapping</code> - Mapping</dd>
<dd><code>bitSet</code> - Bit set</dd>
<dt>Returns:</dt>
<dd>Bit set with mapping applied</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="apply(org.apache.calcite.util.mapping.Mapping,org.apache.calcite.util.ImmutableBitSet)">
<h3>apply</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a></span>&nbsp;<span class="element-name">apply</span><wbr><span class="parameters">(<a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping,
 <a href="../ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;bitSet)</span></div>
<div class="block">Applies a mapping to an <code>ImmutableBitSet</code>.

 <p>If the mapping does not affect the bit set, returns the original.
 Never changes the original.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>mapping</code> - Mapping</dd>
<dd><code>bitSet</code> - Bit set</dd>
<dt>Returns:</dt>
<dd>Bit set with mapping applied</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="apply2(org.apache.calcite.util.mapping.Mapping,java.lang.Iterable)">
<h3>apply2</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">com.google.common.collect.ImmutableList&lt;<a href="../ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&gt;</span>&nbsp;<span class="element-name">apply2</span><wbr><span class="parameters">(<a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping,
 <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="../ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&gt;&nbsp;bitSets)</span></div>
<div class="block">Applies a mapping to a collection of <code>ImmutableBitSet</code>s.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>mapping</code> - Mapping</dd>
<dd><code>bitSets</code> - Collection of bit sets</dd>
<dt>Returns:</dt>
<dd>Sorted bit sets with mapping applied</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="apply(org.apache.calcite.util.mapping.Mapping,java.util.List)">
<h3>apply</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T&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;T&gt;</span>&nbsp;<span class="element-name">apply</span><wbr><span class="parameters">(<a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping,
 <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;list)</span></div>
<div class="block">Applies a mapping to a list.</div>
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>T</code> - Element type</dd>
<dt>Parameters:</dt>
<dd><code>mapping</code> - Mapping</dd>
<dd><code>list</code> - List</dd>
<dt>Returns:</dt>
<dd>List with elements permuted according to mapping</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="apply2(org.apache.calcite.util.mapping.Mapping,java.util.List)">
<h3>apply2</h3>
<div class="member-signature"><span class="modifiers">public static</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;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</span>&nbsp;<span class="element-name">apply2</span><wbr><span class="parameters">(<a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping,
 <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="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;list)</span></div>
</section>
</li>
<li>
<section class="detail" id="apply3(org.apache.calcite.util.mapping.Mapping,java.util.List)">
<h3>apply3</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T&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;T&gt;</span>&nbsp;<span class="element-name">apply3</span><wbr><span class="parameters">(<a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping,
 <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;list)</span></div>
<div class="block">Creates a view of a list, permuting according to a mapping.</div>
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>T</code> - Element type</dd>
<dt>Parameters:</dt>
<dd><code>mapping</code> - Mapping</dd>
<dd><code>list</code> - List</dd>
<dt>Returns:</dt>
<dd>Permuted view of list</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="permute(java.util.List,org.apache.calcite.util.mapping.Mappings.TargetMapping)">
<h3>permute</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T&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;T&gt;</span>&nbsp;<span class="element-name">permute</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;list,
 <a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping)</span></div>
<div class="block">Creates a view of a list, permuting according to a target mapping.</div>
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>T</code> - Element type</dd>
<dt>Parameters:</dt>
<dd><code>mapping</code> - Mapping</dd>
<dd><code>list</code> - List</dd>
<dt>Returns:</dt>
<dd>Permuted view of list</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="asList(org.apache.calcite.util.mapping.Mappings.TargetMapping)">
<h3>asList</h3>
<div class="member-signature"><span class="annotations">@CheckReturnValue
</span><span class="modifiers">public static</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;@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</span>&nbsp;<span class="element-name">asList</span><wbr><span class="parameters">(<a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping)</span></div>
<div class="block">Returns a mapping as a list such that <code>list.get(source)</code> is
 <code>mapping.getTarget(source)</code> and <code>list.size()</code> is
 <code>mapping.getSourceCount()</code>.

 <p>Converse of <a href="#target(java.util.List,int)"><code>target(List, int)</code></a></p></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="#asListNonNull(org.apache.calcite.util.mapping.Mappings.TargetMapping)"><code>asListNonNull(TargetMapping)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="asListNonNull(org.apache.calcite.util.mapping.Mappings.TargetMapping)">
<h3>asListNonNull</h3>
<div class="member-signature"><span class="annotations">@CheckReturnValue
</span><span class="modifiers">public static</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;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</span>&nbsp;<span class="element-name">asListNonNull</span><wbr><span class="parameters">(<a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping)</span></div>
<div class="block">Returns a mapping as a list such that <code>list.get(source)</code> is
 <code>mapping.getTarget(source)</code> and <code>list.size()</code> is
 <code>mapping.getSourceCount()</code>.

 <p>The resulting list never contains null elements</p>

 <p>Converse of <a href="#target(java.util.List,int)"><code>target(List, int)</code></a></p></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="#asList(org.apache.calcite.util.mapping.Mappings.TargetMapping)"><code>asList(TargetMapping)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="target(java.util.Map,int,int)">
<h3>target</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></span>&nbsp;<span class="element-name">target</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;map,
 int&nbsp;sourceCount,
 int&nbsp;targetCount)</span></div>
<div class="block">Converts a <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link"><code>Map</code></a> of integers to a <a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping"><code>Mappings.TargetMapping</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="target(java.util.function.IntFunction,int,int)">
<h3>target</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></span>&nbsp;<span class="element-name">target</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/function/IntFunction.html" title="class or interface in java.util.function" class="external-link">IntFunction</a>&lt;? extends @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;function,
 int&nbsp;sourceCount,
 int&nbsp;targetCount)</span></div>
</section>
</li>
<li>
<section class="detail" id="target(java.lang.Iterable,int,int)">
<h3>target</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a></span>&nbsp;<span class="element-name">target</span><wbr><span class="parameters">(<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="IntPair.html" title="class in org.apache.calcite.util.mapping">IntPair</a>&gt;&nbsp;pairs,
 int&nbsp;sourceCount,
 int&nbsp;targetCount)</span></div>
</section>
</li>
<li>
<section class="detail" id="source(java.util.List,int)">
<h3>source</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a></span>&nbsp;<span class="element-name">source</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;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;targets,
 int&nbsp;targetCount)</span></div>
</section>
</li>
<li>
<section class="detail" id="target(java.util.List,int)">
<h3>target</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a></span>&nbsp;<span class="element-name">target</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;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;sources,
 int&nbsp;sourceCount)</span></div>
</section>
</li>
<li>
<section class="detail" id="bijection(java.util.List)">
<h3>bijection</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a></span>&nbsp;<span class="element-name">bijection</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;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;targets)</span></div>
<div class="block">Creates a bijection.

 <p>Throws if sources and targets are not one to one.</p></div>
</section>
</li>
<li>
<section class="detail" id="bijection(java.util.Map)">
<h3>bijection</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a></span>&nbsp;<span class="element-name">bijection</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;targets)</span></div>
<div class="block">Creates a bijection.

 <p>Throws if sources and targets are not one to one.</div>
</section>
</li>
<li>
<section class="detail" id="isIdentity(org.apache.calcite.util.mapping.Mappings.TargetMapping)">
<h3>isIdentity</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isIdentity</span><wbr><span class="parameters">(<a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping)</span></div>
<div class="block">Returns whether a mapping is the identity.</div>
</section>
</li>
<li>
<section class="detail" id="keepsOrdering(org.apache.calcite.util.mapping.Mappings.TargetMapping)">
<h3>keepsOrdering</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">keepsOrdering</span><wbr><span class="parameters">(<a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping)</span></div>
<div class="block">Returns whether a mapping keeps order.

 <p>For example, {0:0, 1:1} and {0:1, 1:1} keeps order,
 and {0:1, 1:0} breaks the initial order.</div>
</section>
</li>
<li>
<section class="detail" id="createShiftMapping(int,int...)">
<h3>createShiftMapping</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></span>&nbsp;<span class="element-name">createShiftMapping</span><wbr><span class="parameters">(int&nbsp;sourceCount,
 int...&nbsp;ints)</span></div>
<div class="block">Creates a mapping that consists of a set of contiguous ranges.

 <p>For example,</p>

 <blockquote><pre>createShiftMapping(60,
     100, 0, 3,
     200, 50, 5);
 </pre></blockquote>

 <p>creates</p>

 <table>
 <caption>Example mapping</caption>
 <tr><th>Source</th><th>Target</th></tr>
 <tr><td>0</td><td>100</td></tr>
 <tr><td>1</td><td>101</td></tr>
 <tr><td>2</td><td>102</td></tr>
 <tr><td>3</td><td>-1</td></tr>
 <tr><td>...</td><td>-1</td></tr>
 <tr><td>50</td><td>200</td></tr>
 <tr><td>51</td><td>201</td></tr>
 <tr><td>52</td><td>202</td></tr>
 <tr><td>53</td><td>203</td></tr>
 <tr><td>54</td><td>204</td></tr>
 <tr><td>55</td><td>-1</td></tr>
 <tr><td>...</td><td>-1</td></tr>
 <tr><td>59</td><td>-1</td></tr>
 </table></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>sourceCount</code> - Maximum value of <code>source</code></dd>
<dd><code>ints</code> - Collection of ranges, each
                    <code>(target, source, count)</code></dd>
<dt>Returns:</dt>
<dd>Mapping that maps from source ranges to target ranges</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="append(org.apache.calcite.util.mapping.Mappings.TargetMapping,org.apache.calcite.util.mapping.Mappings.TargetMapping)">
<h3>append</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></span>&nbsp;<span class="element-name">append</span><wbr><span class="parameters">(<a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping0,
 <a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping1)</span></div>
<div class="block">Creates a mapping by appending two mappings.

 <p>Sources and targets of the second mapping are shifted to the right.</p>

 <p>For example, <pre>append({0:0, 1:1}, {0:0, 1:1, 2:2})</pre> yields
 <pre>{0:0, 1:1, 2:2, 3:3, 4:4}</pre>.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="#merge(org.apache.calcite.util.mapping.Mappings.TargetMapping,org.apache.calcite.util.mapping.Mappings.TargetMapping)"><code>merge(org.apache.calcite.util.mapping.Mappings.TargetMapping, org.apache.calcite.util.mapping.Mappings.TargetMapping)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="merge(org.apache.calcite.util.mapping.Mappings.TargetMapping,org.apache.calcite.util.mapping.Mappings.TargetMapping)">
<h3>merge</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></span>&nbsp;<span class="element-name">merge</span><wbr><span class="parameters">(<a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping0,
 <a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping1)</span></div>
<div class="block">Creates a mapping by merging two mappings. There must be no clashes.

 <p>Unlike <a href="#append(org.apache.calcite.util.mapping.Mappings.TargetMapping,org.apache.calcite.util.mapping.Mappings.TargetMapping)"><code>append(org.apache.calcite.util.mapping.Mappings.TargetMapping, org.apache.calcite.util.mapping.Mappings.TargetMapping)</code></a>, sources and targets are not shifted.

 <p>For example, <code>merge({0:0, 1:1}, {2:2, 3:3, 4:4})</code> yields
 <code>{0:0, 1:1, 2:2, 3:3, 4:4}</code>.
 <code>merge({0:0, 1:1}, {1:2, 2:3})</code> throws, because there are
 two entries with source=1.</div>
</section>
</li>
<li>
<section class="detail" id="offsetSource(org.apache.calcite.util.mapping.Mappings.TargetMapping,int)">
<h3>offsetSource</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></span>&nbsp;<span class="element-name">offsetSource</span><wbr><span class="parameters">(<a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping,
 int&nbsp;offset)</span></div>
<div class="block">Returns a mapping that shifts a given mapping's source by a given
 offset, incrementing the number of sources by the minimum possible.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>mapping</code> - Input mapping</dd>
<dd><code>offset</code> - Offset to be applied to each source</dd>
<dt>Returns:</dt>
<dd>Shifted mapping</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="offsetSource(org.apache.calcite.util.mapping.Mappings.TargetMapping,int,int)">
<h3>offsetSource</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></span>&nbsp;<span class="element-name">offsetSource</span><wbr><span class="parameters">(<a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping,
 int&nbsp;offset,
 int&nbsp;sourceCount)</span></div>
<div class="block">Returns a mapping that shifts a given mapping's source by a given
 offset.

 <p>For example, given <code>mapping</code> with sourceCount=2, targetCount=8,
 and (source, target) entries {[0: 5], [1: 7]}, offsetSource(mapping, 3)
 returns a mapping with sourceCount=5, targetCount=8,
 and (source, target) entries {[3: 5], [4: 7]}.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>mapping</code> - Input mapping</dd>
<dd><code>offset</code> - Offset to be applied to each source</dd>
<dd><code>sourceCount</code> - New source count; must be at least <code>mapping</code>'s
                    source count plus <code>offset</code></dd>
<dt>Returns:</dt>
<dd>Shifted mapping</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="offsetTarget(org.apache.calcite.util.mapping.Mappings.TargetMapping,int)">
<h3>offsetTarget</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></span>&nbsp;<span class="element-name">offsetTarget</span><wbr><span class="parameters">(<a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping,
 int&nbsp;offset)</span></div>
<div class="block">Returns a mapping that shifts a given mapping's target by a given
 offset, incrementing the number of targets by the minimum possible.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>mapping</code> - Input mapping</dd>
<dd><code>offset</code> - Offset to be applied to each target</dd>
<dt>Returns:</dt>
<dd>Shifted mapping</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="offsetTarget(org.apache.calcite.util.mapping.Mappings.TargetMapping,int,int)">
<h3>offsetTarget</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></span>&nbsp;<span class="element-name">offsetTarget</span><wbr><span class="parameters">(<a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping,
 int&nbsp;offset,
 int&nbsp;targetCount)</span></div>
<div class="block">Returns a mapping that shifts a given mapping's target by a given
 offset.

 <p>For example, given <code>mapping</code> with sourceCount=2, targetCount=8,
 and (source, target) entries {[0: 5], [1: 7]}, offsetTarget(mapping, 3)
 returns a mapping with sourceCount=2, targetCount=11,
 and (source, target) entries {[0: 8], [1: 10]}.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>mapping</code> - Input mapping</dd>
<dd><code>offset</code> - Offset to be applied to each target</dd>
<dd><code>targetCount</code> - New target count; must be at least <code>mapping</code>'s
                    target count plus <code>offset</code></dd>
<dt>Returns:</dt>
<dd>Shifted mapping</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="offset(org.apache.calcite.util.mapping.Mappings.TargetMapping,int,int)">
<h3>offset</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></span>&nbsp;<span class="element-name">offset</span><wbr><span class="parameters">(<a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping,
 int&nbsp;offset,
 int&nbsp;sourceCount)</span></div>
<div class="block">Returns a mapping that shifts a given mapping's source and target by a
 given offset.

 <p>For example, given <code>mapping</code> with sourceCount=2, targetCount=8,
 and (source, target) entries {[0: 5], [1: 7]}, offsetSource(mapping, 3)
 returns a mapping with sourceCount=5, targetCount=8,
 and (source, target) entries {[3: 8], [4: 10]}.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>mapping</code> - Input mapping</dd>
<dd><code>offset</code> - Offset to be applied to each source</dd>
<dd><code>sourceCount</code> - New source count; must be at least <code>mapping</code>'s
                    source count plus <code>offset</code></dd>
<dt>Returns:</dt>
<dd>Shifted mapping</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isIdentity(java.util.List,int)">
<h3>isIdentity</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isIdentity</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;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;list,
 int&nbsp;count)</span></div>
<div class="block">Returns whether a list of integers is the identity mapping
 [0, ..., n - 1].</div>
</section>
</li>
<li>
<section class="detail" id="invert(java.lang.Iterable)">
<h3>invert</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><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="IntPair.html" title="class in org.apache.calcite.util.mapping">IntPair</a>&gt;</span>&nbsp;<span class="element-name">invert</span><wbr><span class="parameters">(<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="IntPair.html" title="class in org.apache.calcite.util.mapping">IntPair</a>&gt;&nbsp;pairs)</span></div>
<div class="block">Inverts an <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"><code>Iterable</code></a> over
 <a href="IntPair.html" title="class in org.apache.calcite.util.mapping"><code>IntPair</code></a>s.</div>
</section>
</li>
<li>
<section class="detail" id="invert(java.util.Iterator)">
<h3>invert</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Iterator.html" title="class or interface in java.util" class="external-link">Iterator</a>&lt;<a href="IntPair.html" title="class in org.apache.calcite.util.mapping">IntPair</a>&gt;</span>&nbsp;<span class="element-name">invert</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Iterator.html" title="class or interface in java.util" class="external-link">Iterator</a>&lt;<a href="IntPair.html" title="class in org.apache.calcite.util.mapping">IntPair</a>&gt;&nbsp;pairs)</span></div>
<div class="block">Inverts an <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Iterator.html" title="class or interface in java.util" class="external-link"><code>Iterator</code></a> over
 <a href="IntPair.html" title="class in org.apache.calcite.util.mapping"><code>IntPair</code></a>s.</div>
</section>
</li>
<li>
<section class="detail" id="apply(org.apache.calcite.util.mapping.Mappings.TargetMapping,int)">
<h3>apply</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">apply</span><wbr><span class="parameters">(<a href="Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping,
 int&nbsp;i)</span></div>
<div class="block">Applies a mapping to an optional integer, returning an optional
 result.</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>
