<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>XSDFuncOp (Apache Jena ARQ)</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: module: org.apache.jena.arq, package: org.apache.jena.sparql.expr.nodevalue, class: XSDFuncOp">
<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.6.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>
<ul id="navbar-top-firstrow" class="nav-list" title="Navigation">
<li><a href="../../../../../../module-summary.html">Module</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="nav-bar-cell1-rev">Class</li>
<li><a href="class-use/XSDFuncOp.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../../../help-doc.html#class">Help</a></li>
</ul>
</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><a href="#field-detail">Field</a>&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="module-label-in-type">Module</span>&nbsp;<a href="../../../../../../module-summary.html">org.apache.jena.arq</a></div>
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.jena.sparql.expr.nodevalue</a></div>
<h1 title="Class XSDFuncOp" class="title">Class XSDFuncOp</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.jena.sparql.expr.nodevalue.XSDFuncOp</div>
</div>
<section class="class-description" id="class-description">
<hr>
<div class="type-signature"><span class="modifiers">public class </span><span class="element-name type-name-label">XSDFuncOp</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">Implementation of XQuery/XPath functions and operators.
 http://www.w3.org/TR/xpath-functions/</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="caption"><span>Fields</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Field</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static final <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 even-row-color"><code><a href="#implicitTimezoneStr" class="member-name-link">implicitTimezoneStr</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.xml/javax/xml/datatype/Duration.html" title="class or interface in javax.xml.datatype" class="external-link">Duration</a></code></div>
<div class="col-second odd-row-color"><code><a href="#zeroDuration" class="member-name-link">zeroDuration</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab1" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab1', 3)" class="table-tab">Static Methods</button><button id="method-summary-table-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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#abs(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">abs</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#adjustToTimezone(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">adjustToTimezone</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Adjust xsd:dateTime/xsd:date/xsd:time to a timezone.</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="#booleanEffectiveValue(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">booleanEffectiveValue</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">F&amp;O fn:boolean</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#booleanEffectiveValueAsNodeValue(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">booleanEffectiveValueAsNodeValue</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">F&amp;O fn:boolean</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/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#canonicalDecimalStr(java.math.BigDecimal)" class="member-name-link">canonicalDecimalStr</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;decimal)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Canonical decimal according to XML Schema Datatype 2.</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/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-tab1 method-summary-table-tab4"><code><a href="#canonicalDecimalStrNoIntegerDot(java.math.BigDecimal)" class="member-name-link">canonicalDecimalStrNoIntegerDot</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;bd)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Decimal format, cast-to-string.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ceiling(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">ceiling</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;v)</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="NumericType.html" title="enum class in org.apache.jena.sparql.expr.nodevalue">NumericType</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#classifyNumeric(java.lang.String,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">classifyNumeric</a><wbr>(<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>&nbsp;fName,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</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="NumericType.html" title="enum class in org.apache.jena.sparql.expr.nodevalue">NumericType</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#classifyNumeric(java.lang.String,org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">classifyNumeric</a><wbr>(<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>&nbsp;fName,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</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 int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#compareBoolean(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">compareBoolean</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</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 int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#compareDateTime(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">compareDateTime</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</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 int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#compareDateTimeFO(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">compareDateTimeFO</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Strict F&amp;O handling of compare date(times).</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="#compareDateTimeXSD(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">compareDateTimeXSD</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Compare two date/times by XSD rules (dateTimes, one with and one without timezone can be indeterminate)</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#compareDuration(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">compareDuration</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</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 int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#compareNumeric(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">compareNumeric</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</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 int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#compareString(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">compareString</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</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 int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#compareXSDDateTime(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">compareXSDDateTime</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Compare date times, including "indeterminate" rather than applying locale timezone</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#dateTimeCast(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.datatypes.xsd.XSDDatatype)" class="member-name-link">dateTimeCast</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv,
 org.apache.jena.datatypes.xsd.XSDDatatype&nbsp;xsd)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Cast a NodeValue to a date/time type (xsd dateTime, date, time, g*) according to F&amp;O
 <a href="http://www.w3.org/TR/xpath-functions/#casting-to-datetimes">17.1.5 Casting to date and time types</a>
 Throws an exception on incorrect case.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#dtDateTime(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">dtDateTime</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Create an xsd:dateTime from an xsd:date and an xsd:time.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#dtGetDay(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">dtGetDay</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#dtGetHours(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">dtGetHours</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#dtGetMinutes(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">dtGetMinutes</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#dtGetMonth(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">dtGetMonth</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#dtGetSeconds(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">dtGetSeconds</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#dtGetTimezone(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">dtGetTimezone</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#dtGetTZ(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">dtGetTZ</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#dtGetYear(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">dtGetYear</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#durGetDays(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">durGetDays</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#durGetHours(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">durGetHours</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#durGetMinutes(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">durGetMinutes</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#durGetMonths(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">durGetMonths</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#durGetSeconds(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">durGetSeconds</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#durGetSign(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">durGetSign</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#durGetYears(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">durGetYears</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#floor(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">floor</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;v)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#fnConcat(java.util.List)" class="member-name-link">fnConcat</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&gt;&nbsp;args)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">F&amp;O fn:concat (implicit cast to strings).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#formatNumber(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">formatNumber</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;picture,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvLocale)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">fn:format-number

 The 3rd argument, if present, called decimal-format-name, is here a
 IETF BCP 47 language tag string.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getDay(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">getDay</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getHours(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">getHours</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getMinutes(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">getMinutes</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getMonth(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">getMonth</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getSeconds(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">getSeconds</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getYear(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">getYear</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#implicitTimezone()" class="member-name-link">implicitTimezone</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block"><a href="https://www.w3.org/TR/xpath-functions-3/#func-implicit-timezone">Implciit Timezone</a>
 // https://www.w3.org/TR/xpath-functions-3/#comp.datetime</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="#isBinaryDatatype(org.apache.jena.datatypes.xsd.XSDDatatype)" class="member-name-link">isBinaryDatatype</a><wbr>(org.apache.jena.datatypes.xsd.XSDDatatype&nbsp;datatype)</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 boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isDayTime(javax.xml.datatype.Duration)" class="member-name-link">isDayTime</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.xml/javax/xml/datatype/Duration.html" title="class or interface in javax.xml.datatype" class="external-link">Duration</a>&nbsp;dur)</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 boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isDecimalDatatype(org.apache.jena.datatypes.xsd.XSDDatatype)" class="member-name-link">isDecimalDatatype</a><wbr>(org.apache.jena.datatypes.xsd.XSDDatatype&nbsp;xsdDatatype)</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 boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isDurationDatatype(org.apache.jena.datatypes.xsd.XSDDatatype)" class="member-name-link">isDurationDatatype</a><wbr>(org.apache.jena.datatypes.xsd.XSDDatatype&nbsp;datatype)</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 boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isIntegerDatatype(org.apache.jena.datatypes.xsd.XSDDatatype)" class="member-name-link">isIntegerDatatype</a><wbr>(org.apache.jena.datatypes.xsd.XSDDatatype&nbsp;xsdDatatype)</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 boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isNumeric(org.apache.jena.graph.Node)" class="member-name-link">isNumeric</a><wbr>(org.apache.jena.graph.Node&nbsp;node)</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 boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isNumericDatatype(org.apache.jena.datatypes.xsd.XSDDatatype)" class="member-name-link">isNumericDatatype</a><wbr>(org.apache.jena.datatypes.xsd.XSDDatatype&nbsp;xsdDatatype)</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 boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isTemporalDatatype(org.apache.jena.datatypes.xsd.XSDDatatype)" class="member-name-link">isTemporalDatatype</a><wbr>(org.apache.jena.datatypes.xsd.XSDDatatype&nbsp;datatype)</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 boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isYearMonth(javax.xml.datatype.Duration)" class="member-name-link">isYearMonth</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.xml/javax/xml/datatype/Duration.html" title="class or interface in javax.xml.datatype" class="external-link">Duration</a>&nbsp;dur)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#javaSprintf(org.apache.jena.sparql.expr.NodeValue,java.util.List)" class="member-name-link">javaSprintf</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvFormat,
 <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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&gt;&nbsp;valuesToPrint)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#javaSubstring(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">javaSubstring</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;v1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;v2)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#javaSubstring(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">javaSubstring</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvString,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvStart,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvFinish)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#localSystemTimezone()" class="member-name-link">localSystemTimezone</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Local timezone of the query engine: afn:system-timezone</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#max(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">max</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#min(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">min</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#not(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">not</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">F&amp;O fn:not</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#numAdd(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">numAdd</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#numDivide(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">numDivide</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#numericMod(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">numericMod</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#numIntegerDivide(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">numIntegerDivide</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Integer divide</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#numMultiply(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">numMultiply</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#numSubtract(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">numSubtract</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#round(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">round</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;v)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#roundXpath3(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue,boolean)" class="member-name-link">roundXpath3</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;v,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;precision,
 boolean&nbsp;isHalfEven)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#sqrt(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">sqrt</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;v)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#strAfter(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">strAfter</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;string,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;match)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#strBefore(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">strBefore</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;string,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;match)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#strConcat(java.util.List)" class="member-name-link">strConcat</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&gt;&nbsp;args)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SPARQL CONCAT (no implicit casts to strings)</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#strContains(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">strContains</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;string,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;match)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#strEncodeForURI(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">strEncodeForURI</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;v)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#strEndsWith(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">strEndsWith</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;string,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;match)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#strlen(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">strlen</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvString)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#strLowerCase(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">strLowerCase</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;string)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#strNormalizeSpace(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">strNormalizeSpace</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;v)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">fn:normalizeSpace</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#strNormalizeUnicode(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">strNormalizeUnicode</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;v1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;v2)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#strReplace(org.apache.jena.sparql.expr.NodeValue,java.util.regex.Pattern,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">strReplace</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvStr,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/regex/Pattern.html" title="class or interface in java.util.regex" class="external-link">Pattern</a>&nbsp;pattern,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvReplacement)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#strReplace(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">strReplace</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvStr,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvPattern,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvReplacement)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#strReplace(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">strReplace</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvStr,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvPattern,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvReplacement,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvFlags)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#strStartsWith(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">strStartsWith</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;string,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;match)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#strUpperCase(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">strUpperCase</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;string)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#substring(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">substring</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;v1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;v2)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#substring(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">substring</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvString,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvStart,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvLength)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#unaryMinus(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">unaryMinus</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#unaryPlus(org.apache.jena.sparql.expr.NodeValue)" class="member-name-link">unaryPlus</a><wbr>(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-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#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#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">
<!-- ============ FIELD DETAIL =========== -->
<li>
<section class="field-details" id="field-detail">
<h2>Field Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="zeroDuration">
<h3>zeroDuration</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.xml/javax/xml/datatype/Duration.html" title="class or interface in javax.xml.datatype" class="external-link">Duration</a></span>&nbsp;<span class="element-name">zeroDuration</span></div>
</section>
</li>
<li>
<section class="detail" id="implicitTimezoneStr">
<h3>implicitTimezoneStr</h3>
<div class="member-signature"><span class="modifiers">public static final</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">implicitTimezoneStr</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../../../constant-values.html#org.apache.jena.sparql.expr.nodevalue.XSDFuncOp.implicitTimezoneStr">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="numAdd(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>numAdd</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">numAdd</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</span></div>
</section>
</li>
<li>
<section class="detail" id="numSubtract(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>numSubtract</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">numSubtract</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</span></div>
</section>
</li>
<li>
<section class="detail" id="numMultiply(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>numMultiply</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">numMultiply</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</span></div>
</section>
</li>
<li>
<section class="detail" id="numDivide(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>numDivide</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">numDivide</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</span></div>
</section>
</li>
<li>
<section class="detail" id="numIntegerDivide(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>numIntegerDivide</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">numIntegerDivide</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</span></div>
<div class="block">Integer divide</div>
</section>
</li>
<li>
<section class="detail" id="numericMod(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>numericMod</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">numericMod</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</span></div>
</section>
</li>
<li>
<section class="detail" id="canonicalDecimalStrNoIntegerDot(java.math.BigDecimal)">
<h3>canonicalDecimalStrNoIntegerDot</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/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">canonicalDecimalStrNoIntegerDot</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;bd)</span></div>
<div class="block">Decimal format, cast-to-string.
 <p>
 Decimal canonical form where integer values have no ".0" (as in XSD 1.1).
 <p>
 In XSD 2, canonical integer-valued decimal has a trailing ".0".
 In F&amp;O v 3.1, xs:string cast of a decimal which integer valued, does not have the trailing ".0".</div>
</section>
</li>
<li>
<section class="detail" id="canonicalDecimalStr(java.math.BigDecimal)">
<h3>canonicalDecimalStr</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/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">canonicalDecimalStr</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;decimal)</span></div>
<div class="block">Canonical decimal according to XML Schema Datatype 2.
 Integer-valued decimals have a trailing ".0".
 (In XML Schema Datatype 1.1 they did not have a ".0".)
 <p>
 Java BigDecimal.toPlainString does not produce XSD 2 compatible lexical forms for integer values.</div>
</section>
</li>
<li>
<section class="detail" id="max(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>max</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">max</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</span></div>
</section>
</li>
<li>
<section class="detail" id="min(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>min</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">min</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</span></div>
</section>
</li>
<li>
<section class="detail" id="not(org.apache.jena.sparql.expr.NodeValue)">
<h3>not</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">not</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
<div class="block">F&amp;O fn:not</div>
</section>
</li>
<li>
<section class="detail" id="booleanEffectiveValueAsNodeValue(org.apache.jena.sparql.expr.NodeValue)">
<h3>booleanEffectiveValueAsNodeValue</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">booleanEffectiveValueAsNodeValue</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
<div class="block">F&amp;O fn:boolean</div>
</section>
</li>
<li>
<section class="detail" id="booleanEffectiveValue(org.apache.jena.sparql.expr.NodeValue)">
<h3>booleanEffectiveValue</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">booleanEffectiveValue</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
<div class="block">F&amp;O fn:boolean</div>
</section>
</li>
<li>
<section class="detail" id="unaryMinus(org.apache.jena.sparql.expr.NodeValue)">
<h3>unaryMinus</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">unaryMinus</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
</section>
</li>
<li>
<section class="detail" id="unaryPlus(org.apache.jena.sparql.expr.NodeValue)">
<h3>unaryPlus</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">unaryPlus</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
</section>
</li>
<li>
<section class="detail" id="abs(org.apache.jena.sparql.expr.NodeValue)">
<h3>abs</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">abs</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
</section>
</li>
<li>
<section class="detail" id="ceiling(org.apache.jena.sparql.expr.NodeValue)">
<h3>ceiling</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">ceiling</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;v)</span></div>
</section>
</li>
<li>
<section class="detail" id="floor(org.apache.jena.sparql.expr.NodeValue)">
<h3>floor</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">floor</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;v)</span></div>
</section>
</li>
<li>
<section class="detail" id="round(org.apache.jena.sparql.expr.NodeValue)">
<h3>round</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">round</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;v)</span></div>
</section>
</li>
<li>
<section class="detail" id="roundXpath3(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue,boolean)">
<h3>roundXpath3</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">roundXpath3</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;v,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;precision,
 boolean&nbsp;isHalfEven)</span></div>
</section>
</li>
<li>
<section class="detail" id="sqrt(org.apache.jena.sparql.expr.NodeValue)">
<h3>sqrt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">sqrt</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;v)</span></div>
</section>
</li>
<li>
<section class="detail" id="javaSubstring(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>javaSubstring</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">javaSubstring</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;v1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;v2)</span></div>
</section>
</li>
<li>
<section class="detail" id="javaSubstring(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>javaSubstring</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">javaSubstring</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvString,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvStart,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvFinish)</span></div>
</section>
</li>
<li>
<section class="detail" id="javaSprintf(org.apache.jena.sparql.expr.NodeValue,java.util.List)">
<h3>javaSprintf</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">javaSprintf</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvFormat,
 <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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&gt;&nbsp;valuesToPrint)</span></div>
</section>
</li>
<li>
<section class="detail" id="strlen(org.apache.jena.sparql.expr.NodeValue)">
<h3>strlen</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">strlen</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvString)</span></div>
</section>
</li>
<li>
<section class="detail" id="strReplace(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>strReplace</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">strReplace</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvStr,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvPattern,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvReplacement,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvFlags)</span></div>
</section>
</li>
<li>
<section class="detail" id="strReplace(org.apache.jena.sparql.expr.NodeValue,java.util.regex.Pattern,org.apache.jena.sparql.expr.NodeValue)">
<h3>strReplace</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">strReplace</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvStr,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/regex/Pattern.html" title="class or interface in java.util.regex" class="external-link">Pattern</a>&nbsp;pattern,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvReplacement)</span></div>
</section>
</li>
<li>
<section class="detail" id="strReplace(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>strReplace</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">strReplace</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvStr,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvPattern,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvReplacement)</span></div>
</section>
</li>
<li>
<section class="detail" id="substring(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>substring</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">substring</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;v1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;v2)</span></div>
</section>
</li>
<li>
<section class="detail" id="substring(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>substring</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">substring</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvString,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvStart,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvLength)</span></div>
</section>
</li>
<li>
<section class="detail" id="strContains(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>strContains</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">strContains</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;string,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;match)</span></div>
</section>
</li>
<li>
<section class="detail" id="strStartsWith(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>strStartsWith</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">strStartsWith</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;string,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;match)</span></div>
</section>
</li>
<li>
<section class="detail" id="strEndsWith(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>strEndsWith</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">strEndsWith</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;string,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;match)</span></div>
</section>
</li>
<li>
<section class="detail" id="strBefore(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>strBefore</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">strBefore</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;string,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;match)</span></div>
</section>
</li>
<li>
<section class="detail" id="strAfter(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>strAfter</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">strAfter</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;string,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;match)</span></div>
</section>
</li>
<li>
<section class="detail" id="strLowerCase(org.apache.jena.sparql.expr.NodeValue)">
<h3>strLowerCase</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">strLowerCase</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;string)</span></div>
</section>
</li>
<li>
<section class="detail" id="strUpperCase(org.apache.jena.sparql.expr.NodeValue)">
<h3>strUpperCase</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">strUpperCase</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;string)</span></div>
</section>
</li>
<li>
<section class="detail" id="strEncodeForURI(org.apache.jena.sparql.expr.NodeValue)">
<h3>strEncodeForURI</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">strEncodeForURI</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;v)</span></div>
</section>
</li>
<li>
<section class="detail" id="fnConcat(java.util.List)">
<h3>fnConcat</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">fnConcat</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&gt;&nbsp;args)</span></div>
<div class="block">F&amp;O fn:concat (implicit cast to strings).</div>
</section>
</li>
<li>
<section class="detail" id="strConcat(java.util.List)">
<h3>strConcat</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">strConcat</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="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&gt;&nbsp;args)</span></div>
<div class="block">SPARQL CONCAT (no implicit casts to strings)</div>
</section>
</li>
<li>
<section class="detail" id="strNormalizeSpace(org.apache.jena.sparql.expr.NodeValue)">
<h3>strNormalizeSpace</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">strNormalizeSpace</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;v)</span></div>
<div class="block">fn:normalizeSpace</div>
</section>
</li>
<li>
<section class="detail" id="strNormalizeUnicode(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>strNormalizeUnicode</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">strNormalizeUnicode</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;v1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;v2)</span></div>
</section>
</li>
<li>
<section class="detail" id="classifyNumeric(java.lang.String,org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>classifyNumeric</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="NumericType.html" title="enum class in org.apache.jena.sparql.expr.nodevalue">NumericType</a></span>&nbsp;<span class="element-name">classifyNumeric</span><wbr><span class="parameters">(<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>&nbsp;fName,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</span></div>
</section>
</li>
<li>
<section class="detail" id="classifyNumeric(java.lang.String,org.apache.jena.sparql.expr.NodeValue)">
<h3>classifyNumeric</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="NumericType.html" title="enum class in org.apache.jena.sparql.expr.nodevalue">NumericType</a></span>&nbsp;<span class="element-name">classifyNumeric</span><wbr><span class="parameters">(<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>&nbsp;fName,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
</section>
</li>
<li>
<section class="detail" id="isNumericDatatype(org.apache.jena.datatypes.xsd.XSDDatatype)">
<h3>isNumericDatatype</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isNumericDatatype</span><wbr><span class="parameters">(org.apache.jena.datatypes.xsd.XSDDatatype&nbsp;xsdDatatype)</span></div>
</section>
</li>
<li>
<section class="detail" id="isNumeric(org.apache.jena.graph.Node)">
<h3>isNumeric</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isNumeric</span><wbr><span class="parameters">(org.apache.jena.graph.Node&nbsp;node)</span></div>
</section>
</li>
<li>
<section class="detail" id="isDecimalDatatype(org.apache.jena.datatypes.xsd.XSDDatatype)">
<h3>isDecimalDatatype</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isDecimalDatatype</span><wbr><span class="parameters">(org.apache.jena.datatypes.xsd.XSDDatatype&nbsp;xsdDatatype)</span></div>
</section>
</li>
<li>
<section class="detail" id="isIntegerDatatype(org.apache.jena.datatypes.xsd.XSDDatatype)">
<h3>isIntegerDatatype</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isIntegerDatatype</span><wbr><span class="parameters">(org.apache.jena.datatypes.xsd.XSDDatatype&nbsp;xsdDatatype)</span></div>
</section>
</li>
<li>
<section class="detail" id="isTemporalDatatype(org.apache.jena.datatypes.xsd.XSDDatatype)">
<h3>isTemporalDatatype</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isTemporalDatatype</span><wbr><span class="parameters">(org.apache.jena.datatypes.xsd.XSDDatatype&nbsp;datatype)</span></div>
</section>
</li>
<li>
<section class="detail" id="isDurationDatatype(org.apache.jena.datatypes.xsd.XSDDatatype)">
<h3>isDurationDatatype</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isDurationDatatype</span><wbr><span class="parameters">(org.apache.jena.datatypes.xsd.XSDDatatype&nbsp;datatype)</span></div>
</section>
</li>
<li>
<section class="detail" id="isBinaryDatatype(org.apache.jena.datatypes.xsd.XSDDatatype)">
<h3>isBinaryDatatype</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isBinaryDatatype</span><wbr><span class="parameters">(org.apache.jena.datatypes.xsd.XSDDatatype&nbsp;datatype)</span></div>
</section>
</li>
<li>
<section class="detail" id="compareNumeric(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>compareNumeric</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">compareNumeric</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</span></div>
</section>
</li>
<li>
<section class="detail" id="compareString(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>compareString</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">compareString</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</span></div>
</section>
</li>
<li>
<section class="detail" id="compareDateTime(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>compareDateTime</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">compareDateTime</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</span></div>
</section>
</li>
<li>
<section class="detail" id="compareDateTimeXSD(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>compareDateTimeXSD</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">compareDateTimeXSD</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</span></div>
<div class="block">Compare two date/times by XSD rules (dateTimes, one with and one without timezone can be indeterminate)</div>
</section>
</li>
<li>
<section class="detail" id="compareDateTimeFO(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>compareDateTimeFO</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">compareDateTimeFO</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</span></div>
<div class="block">Strict F&amp;O handling of compare date(times).
 But that means applying the "local" timezone if there is no TZ.
 The data may have come from different timezones to the query.
 We use a fixed locale timezone of UTC/00:00.</div>
</section>
</li>
<li>
<section class="detail" id="compareXSDDateTime(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>compareXSDDateTime</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">compareXSDDateTime</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</span></div>
<div class="block">Compare date times, including "indeterminate" rather than applying locale timezone</div>
</section>
</li>
<li>
<section class="detail" id="compareBoolean(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>compareBoolean</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">compareBoolean</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</span></div>
</section>
</li>
<li>
<section class="detail" id="dateTimeCast(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.datatypes.xsd.XSDDatatype)">
<h3>dateTimeCast</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">dateTimeCast</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv,
 org.apache.jena.datatypes.xsd.XSDDatatype&nbsp;xsd)</span></div>
<div class="block">Cast a NodeValue to a date/time type (xsd dateTime, date, time, g*) according to F&amp;O
 <a href="http://www.w3.org/TR/xpath-functions/#casting-to-datetimes">17.1.5 Casting to date and time types</a>
 Throws an exception on incorrect case.</div>
<dl class="notes">
<dt>Throws:</dt>
<dd><code><a href="../ExprEvalTypeException.html" title="class in org.apache.jena.sparql.expr">ExprEvalTypeException</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getYear(org.apache.jena.sparql.expr.NodeValue)">
<h3>getYear</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">getYear</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
</section>
</li>
<li>
<section class="detail" id="getMonth(org.apache.jena.sparql.expr.NodeValue)">
<h3>getMonth</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">getMonth</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
</section>
</li>
<li>
<section class="detail" id="getDay(org.apache.jena.sparql.expr.NodeValue)">
<h3>getDay</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">getDay</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
</section>
</li>
<li>
<section class="detail" id="getHours(org.apache.jena.sparql.expr.NodeValue)">
<h3>getHours</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">getHours</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
</section>
</li>
<li>
<section class="detail" id="getMinutes(org.apache.jena.sparql.expr.NodeValue)">
<h3>getMinutes</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">getMinutes</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
</section>
</li>
<li>
<section class="detail" id="getSeconds(org.apache.jena.sparql.expr.NodeValue)">
<h3>getSeconds</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">getSeconds</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
</section>
</li>
<li>
<section class="detail" id="dtDateTime(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>dtDateTime</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">dtDateTime</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</span></div>
<div class="block">Create an xsd:dateTime from an xsd:date and an xsd:time.</div>
</section>
</li>
<li>
<section class="detail" id="dtGetYear(org.apache.jena.sparql.expr.NodeValue)">
<h3>dtGetYear</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">dtGetYear</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
</section>
</li>
<li>
<section class="detail" id="dtGetMonth(org.apache.jena.sparql.expr.NodeValue)">
<h3>dtGetMonth</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">dtGetMonth</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
</section>
</li>
<li>
<section class="detail" id="dtGetDay(org.apache.jena.sparql.expr.NodeValue)">
<h3>dtGetDay</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">dtGetDay</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
</section>
</li>
<li>
<section class="detail" id="dtGetHours(org.apache.jena.sparql.expr.NodeValue)">
<h3>dtGetHours</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">dtGetHours</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
</section>
</li>
<li>
<section class="detail" id="dtGetMinutes(org.apache.jena.sparql.expr.NodeValue)">
<h3>dtGetMinutes</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">dtGetMinutes</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
</section>
</li>
<li>
<section class="detail" id="dtGetSeconds(org.apache.jena.sparql.expr.NodeValue)">
<h3>dtGetSeconds</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">dtGetSeconds</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
</section>
</li>
<li>
<section class="detail" id="dtGetTZ(org.apache.jena.sparql.expr.NodeValue)">
<h3>dtGetTZ</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">dtGetTZ</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
</section>
</li>
<li>
<section class="detail" id="dtGetTimezone(org.apache.jena.sparql.expr.NodeValue)">
<h3>dtGetTimezone</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">dtGetTimezone</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
</section>
</li>
<li>
<section class="detail" id="isYearMonth(javax.xml.datatype.Duration)">
<h3>isYearMonth</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isYearMonth</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.xml/javax/xml/datatype/Duration.html" title="class or interface in javax.xml.datatype" class="external-link">Duration</a>&nbsp;dur)</span></div>
</section>
</li>
<li>
<section class="detail" id="isDayTime(javax.xml.datatype.Duration)">
<h3>isDayTime</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isDayTime</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.xml/javax/xml/datatype/Duration.html" title="class or interface in javax.xml.datatype" class="external-link">Duration</a>&nbsp;dur)</span></div>
</section>
</li>
<li>
<section class="detail" id="durGetYears(org.apache.jena.sparql.expr.NodeValue)">
<h3>durGetYears</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">durGetYears</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
</section>
</li>
<li>
<section class="detail" id="durGetMonths(org.apache.jena.sparql.expr.NodeValue)">
<h3>durGetMonths</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">durGetMonths</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
</section>
</li>
<li>
<section class="detail" id="durGetDays(org.apache.jena.sparql.expr.NodeValue)">
<h3>durGetDays</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">durGetDays</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
</section>
</li>
<li>
<section class="detail" id="durGetHours(org.apache.jena.sparql.expr.NodeValue)">
<h3>durGetHours</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">durGetHours</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
</section>
</li>
<li>
<section class="detail" id="durGetMinutes(org.apache.jena.sparql.expr.NodeValue)">
<h3>durGetMinutes</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">durGetMinutes</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
</section>
</li>
<li>
<section class="detail" id="durGetSeconds(org.apache.jena.sparql.expr.NodeValue)">
<h3>durGetSeconds</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">durGetSeconds</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
</section>
</li>
<li>
<section class="detail" id="durGetSign(org.apache.jena.sparql.expr.NodeValue)">
<h3>durGetSign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">durGetSign</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv)</span></div>
</section>
</li>
<li>
<section class="detail" id="compareDuration(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>compareDuration</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">compareDuration</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</span></div>
</section>
</li>
<li>
<section class="detail" id="implicitTimezone()">
<h3>implicitTimezone</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">implicitTimezone</span>()</div>
<div class="block"><a href="https://www.w3.org/TR/xpath-functions-3/#func-implicit-timezone">Implciit Timezone</a>
 // https://www.w3.org/TR/xpath-functions-3/#comp.datetime</div>
</section>
</li>
<li>
<section class="detail" id="localSystemTimezone()">
<h3>localSystemTimezone</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">localSystemTimezone</span>()</div>
<div class="block">Local timezone of the query engine: afn:system-timezone</div>
</section>
</li>
<li>
<section class="detail" id="adjustToTimezone(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>adjustToTimezone</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">adjustToTimezone</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv1,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv2)</span></div>
<div class="block">Adjust xsd:dateTime/xsd:date/xsd:time to a timezone.
 This covers fn:adjust-dateTime-to-timezone, fn:adjust-date-to-timezone and fn:adjust-time-to-timezone.
 via <code>ADJUST</code> (<a href="../E_AdjustToTimezone.html" title="class in org.apache.jena.sparql.expr"><code>E_AdjustToTimezone</code></a>).
 If the second argument is null, use implicit timezone.
 In Jena, the implicit timezone is fixed to UTC.</div>
</section>
</li>
<li>
<section class="detail" id="formatNumber(org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue,org.apache.jena.sparql.expr.NodeValue)">
<h3>formatNumber</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a></span>&nbsp;<span class="element-name">formatNumber</span><wbr><span class="parameters">(<a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nv,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;picture,
 <a href="../NodeValue.html" title="class in org.apache.jena.sparql.expr">NodeValue</a>&nbsp;nvLocale)</span></div>
<div class="block">fn:format-number

 The 3rd argument, if present, called decimal-format-name, is here a
 IETF BCP 47 language tag string.</div>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Licensed under the Apache License, Version 2.0</small></p>
</footer>
</div>
</div>
</body>
</html>
