http://www.functx.com

Description

Before using any of the functions below please remember to import the module namespace:

import module namespace functx = "http://www.functx.com";

-------------------------------- The FunctX XQuery Function Library -------------------------------- Copyright (C) 2007 Datypic This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA For more information on the FunctX XQuery library, contact contrib@functx.com.

Module code

Here is the actual XQuery module code.

Version Declaration

xquery version "3.0";

Namespaces

functx	http://www.functx.com

Function Summary

add-attributes($elements as element(), $attrNames as xs:QName, $attrValues as xs:anyAtomicType) as element(*)? Adds attributes to XML elements .
add-months($date as xs:anyAtomicType?, $months as xs:integer) as xs:date? Adds months to a date .
add-or-update-attributes($elements as element(), $attrNames as xs:QName, $attrValues as xs:anyAtomicType) as element(*)? Adds attributes to XML elements .
all-whitespace($arg as xs:string?) as xs:boolean Whether a value is all whitespace or a zero-length string .
are-distinct-values($seq as xs:anyAtomicType*) as xs:boolean Whether all the values in a sequence are distinct .
atomic-type($values as xs:anyAtomicType) as xs:string The built-in type of an atomic value .
avg-empty-is-zero($values as xs:anyAtomicType, $allNodes as node()) as xs:double The average, counting "empty" values as zero .
between-exclusive($value as xs:anyAtomicType?, $minValue as xs:anyAtomicType, $maxValue as xs:anyAtomicType) as xs:boolean Whether a value is between two provided values .
between-inclusive($value as xs:anyAtomicType?, $minValue as xs:anyAtomicType, $maxValue as xs:anyAtomicType) as xs:boolean Whether a value is between two provided values, or equal to one of them .
camel-case-to-words($arg as xs:string?, $delim as xs:string) as xs:string Turns a camelCase string into space-separated words .
capitalize-first($arg as xs:string?) as xs:string? Capitalizes the first character of a string .
change-element-names-deep($nodes as node(), $oldNames as xs:QName, $newNames as xs:QName) as node() Changes the names of elements in an XML fragment .
change-element-ns-deep($nodes as node(), $newns as xs:string, $prefix as xs:string) as node() Changes the namespace of XML elements and its descendants .
change-element-ns($elements as element(), $newns as xs:string, $prefix as xs:string) as element(*)? Changes the namespace of XML elements .
chars($arg as xs:string?) as xs:string* Converts a string to a sequence of characters .
contains-any-of($arg as xs:string?, $searchStrings as xs:string*) as xs:boolean Whether a string contains any of a sequence of strings .
contains-case-insensitive($arg as xs:string?, $substring as xs:string) as xs:boolean? Whether one string contains another, without regard to case .
contains-word($arg as xs:string?, $word as xs:string) as xs:boolean Whether one string contains another, as a separate word .
copy-attributes($copyTo as element(), $copyFrom as element()) as element(*) Copies attributes from one element to another .
date($year as xs:anyAtomicType, $month as xs:anyAtomicType, $day as xs:anyAtomicType) as xs:date Construct a date from a year, month and day .
dateTime($year as xs:anyAtomicType, $month as xs:anyAtomicType, $day as xs:anyAtomicType, $hour as xs:anyAtomicType, $minute as xs:anyAtomicType, $second as xs:anyAtomicType) as xs:dateTime Construct a date/time from individual components .
day-in-year($date as xs:anyAtomicType?) as xs:integer? The day of the year (a number between 1 and 366) .
day-of-week-abbrev-en($date as xs:anyAtomicType?) as xs:string? The abbreviated day of the week, from a date, in English .
day-of-week-name-en($date as xs:anyAtomicType?) as xs:string? The name of the day of the week, from a date, in English .
day-of-week($date as xs:anyAtomicType?) as xs:integer? The day of the week, from a date .
dayTimeDuration($days as xs:decimal?, $hours as xs:decimal?, $minutes as xs:decimal?, $seconds as xs:decimal?) as xs:dayTimeDuration Construct a dayTimeDuration from a number of days, hours, etc.
days-in-month($date as xs:anyAtomicType?) as xs:integer? Number of days in the month .
depth-of-node($node as node()?) as xs:integer The depth (level) of a node in an XML tree .
distinct-attribute-names($nodes as node()) as xs:string The distinct names of all attributes in an XML fragment .
distinct-deep($nodes as node()) as node() The XML nodes with distinct values, taking into account attributes and descendants .
distinct-element-names($nodes as node()) as xs:string The distinct names of all elements in an XML fragment .
distinct-element-paths($nodes as node()) as xs:string The distinct paths of all descendant elements in an XML fragment .
distinct-nodes($nodes as node()) as node() The distinct XML nodes in a sequence (by node identity) .
duration-from-timezone($timezone as xs:string) as xs:dayTimeDuration Converts a timezone like "-05:00" or "Z" into xs:dayTimeDuration .
dynamic-path($parent as node(), $path as xs:string) as item()* Dynamically evaluates a simple XPath path .
escape-for-regex($arg as xs:string?) as xs:string Escapes regex special characters .
exclusive-or($arg1 as xs:boolean?, $arg2 as xs:boolean?) as xs:boolean? Whether one (and only one) of two boolean values is true .
first-day-of-month($date as xs:anyAtomicType?) as xs:date? The first day of the month of a date .
first-day-of-year($date as xs:anyAtomicType?) as xs:date? The first day of the year of a date .
first-node($nodes as node()*) as node()? The XML node in a sequence that appears first in document order .
follows-not-descendant($a as node()?, $b as node()?) as xs:boolean Whether an XML node follows another without being its descendant .
format-as-title-en($titles as xs:string) as xs:string Moves title words like "the" and "a" to the end of strings .
fragment-from-uri($uri as xs:string?) as xs:string? Returns the fragment from a URI .
get-matches-and-non-matches($string as xs:string?, $regex as xs:string) as element() Splits a string into matching and non-matching regions .
get-matches($string as xs:string?, $regex as xs:string) as xs:string* Return the matching regions of a string .
has-element-only-content($element as element(*)) as xs:boolean Whether an element has element-only content .
has-empty-content($element as element(*)) as xs:boolean Whether an element has empty content .
has-mixed-content($element as element(*)) as xs:boolean Whether an element has mixed content .
has-simple-content($element as element(*)) as xs:boolean Whether an element has simple content .
id-from-element($element as element(*)?) as xs:string? Gets the ID of an XML element .
id-untyped($node as node(), $id as xs:anyAtomicType) as element()* Gets XML element(s) that have an attribute with a particular value .
if-absent($arg as item(), $value as item()) as item()* The first argument if it is not empty, otherwise the second argument .
if-empty($arg as item()?, $value as item()) as item() The first argument if it is not blank, otherwise the second argument .
index-of-deep-equal-node($nodes as node(), $nodeToFind as node()) as xs:integer The position of a node in a sequence, based on contents and attributes .
index-of-match-first($arg as xs:string?, $pattern as xs:string) as xs:integer? The first position of a matching substring .
index-of-node($nodes as node(), $nodeToFind as node()) as xs:integer The position of a node in a sequence, based on node identity .
index-of-string-first($arg as xs:string?, $substring as xs:string) as xs:integer? The first position of a substring .
index-of-string-last($arg as xs:string?, $substring as xs:string) as xs:integer? The last position of a substring .
index-of-string($arg as xs:string?, $substring as xs:string) as xs:integer* The position(s) of a substring .
insert-string($originalString as xs:string?, $stringToInsert as xs:string?, $pos as xs:integer) as xs:string Inserts a string at a specified position .
is-a-number($value as xs:anyAtomicType?) as xs:boolean Whether a value is numeric .
is-absolute-uri($uri as xs:string?) as xs:boolean Whether a URI is absolute .
is-ancestor($node1 as node(), $node2 as node()) as xs:boolean Whether an XML node is an ancestor of another node .
is-descendant($node1 as node(), $node2 as node()) as xs:boolean Whether an XML node is a descendant of another node .
is-leap-year($date as xs:anyAtomicType?) as xs:boolean Whether a date falls in a leap year .
is-node-among-descendants-deep-equal($node as node()?, $seq as node()*) as xs:boolean Whether an XML node is among the descendants of a sequence, based on contents and attributes .
is-node-among-descendants($node as node()?, $seq as node()*) as xs:boolean Whether an XML node is among the descendants of a sequence, based on node identity .
is-node-in-sequence-deep-equal($node as node()?, $seq as node()*) as xs:boolean Whether an XML node is in a sequence, based on contents and attributes .
is-node-in-sequence($node as node()?, $seq as node()*) as xs:boolean Whether an XML node is in a sequence, based on node identity .
is-value-in-sequence($value as xs:anyAtomicType?, $seq as xs:anyAtomicType*) as xs:boolean Whether an atomic value appears in a sequence .
last-day-of-month($date as xs:anyAtomicType?) as xs:date? The last day of the month of a date .
last-day-of-year($date as xs:anyAtomicType?) as xs:date? The last day of the month of a date .
last-node($nodes as node()*) as node()? The XML node in a sequence that is last in document order .
leaf-elements($root as node()?) as element() All XML elements that don't have any child elements .
left-trim($arg as xs:string?) as xs:string Trims leading whitespace .
line-count($arg as xs:string?) as xs:integer The number of lines .
lines($arg as xs:string?) as xs:string* Split a string into separate lines .
max-depth($root as node()?) as xs:integer? The maximum depth of elements in an XML tree .
max-determine-type($seq as xs:anyAtomicType*) as xs:anyAtomicType? The maximum value in a sequence, figuring out its type (numeric or string) .
max-line-length($arg as xs:string?) as xs:integer The maximum line length .
max-node($nodes as node()) as node() The XML node whose typed value is the maximum .
max-string($strings as xs:anyAtomicType*) as xs:string? The maximum of a sequence of values, treating them like strings .
min-determine-type($seq as xs:anyAtomicType*) as xs:anyAtomicType? The minimum value in a sequence, figuring out its type (numeric or string) .
min-node($nodes as node()) as node() The XML node whose typed value is the minimum .
min-non-empty-string($strings as xs:string*) as xs:string? The minimum of a sequence of strings, ignoring "empty" values .
min-string($strings as xs:anyAtomicType*) as xs:string? The minimum of a sequence of values, treating them like strings .
mmddyyyy-to-date($dateString as xs:string?) as xs:date? Converts a string with format MMDDYYYY (with any delimiters) to a date .
month-abbrev-en($date as xs:anyAtomicType?) as xs:string? The month of a date as an abbreviated word (Jan, Feb, etc.
month-name-en($date as xs:anyAtomicType?) as xs:string? The month of a date as a word (January, February, etc.
name-test($testname as xs:string?, $names as xs:string*) as xs:boolean Whether a name matches a list of names or name wildcards .
namespaces-in-use($root as node()?) as xs:anyURI* A list of namespaces used in element/attribute names in an XML fragment .
next-day($date as xs:anyAtomicType?) as xs:date? The next day .
node-kind($nodes as node()) as xs:string The XML node kind (element, attribute, text, etc.
non-distinct-values($seq as xs:anyAtomicType) as xs:anyAtomicType Returns any values that appear more than once in a sequence .
number-of-matches($arg as xs:string?, $pattern as xs:string) as xs:integer The number of regions that match a pattern .
open-ref-document($refNode as node()) as document() Resolves a relative URI and references it, returning an XML document .
ordinal-number-en($num as xs:integer?) as xs:string Reformats a number as an ordinal number, e.
pad-integer-to-length($integerToPad as xs:anyAtomicType?, $length as xs:integer) as xs:string Pads an integer to a desired length by adding leading zeros .
pad-string-to-length($stringToPad as xs:string?, $padChar as xs:string, $length as xs:integer) as xs:string Pads a string to a desired length .
path-to-node-with-pos($node as node()?) as xs:string A unique path to an XML node (or sequence of nodes) .
path-to-node($nodes as node()) as xs:string A path to an XML node (or sequence of nodes) .
precedes-not-ancestor($a as node()?, $b as node()?) as xs:boolean Whether an XML node precedes another without being its ancestor .
previous-day($date as xs:anyAtomicType?) as xs:date? The previous day .
remove-attributes-deep($nodes as node(), $names as xs:string) as node()* Removes attributes from an XML fragment, based on name .
remove-attributes($elements as element(), $names as xs:string) as element() Removes attributes from an XML element, based on name .
remove-elements-deep($nodes as node(), $names as xs:string) as node()* Removes descendant elements from an XML node, based on name .
remove-elements-not-contents($nodes as node(), $names as xs:string) as node()* Removes descendant XML elements but keeps their content .
remove-elements($elements as element(), $names as xs:string) as element()* Removes child elements from an XML node, based on name .
repeat-string($stringToRepeat as xs:string?, $count as xs:integer) as xs:string Repeats a string a given number of times .
replace-beginning($arg as xs:string?, $pattern as xs:string, $replacement as xs:string) as xs:string Replaces the beginning of a string, up to a matched pattern .
replace-element-values($elements as element(), $values as xs:anyAtomicType) as element()* Updates the content of one or more elements .
replace-first($arg as xs:string?, $pattern as xs:string, $replacement as xs:string) as xs:string Replaces the first match of a pattern .
replace-multi($arg as xs:string?, $changeFrom as xs:string, $changeTo as xs:string) as xs:string? Performs multiple replacements, using pairs of replace parameters .
reverse-string($arg as xs:string?) as xs:string Reverses the order of characters .
right-trim($arg as xs:string?) as xs:string Trims trailing whitespace .
scheme-from-uri($uri as xs:string?) as xs:string? Returns the scheme from a URI .
sequence-deep-equal($seq1 as item(), $seq2 as item()) as xs:boolean Whether two sequences have the same XML node content and/or values .
sequence-node-equal-any-order($seq1 as node(), $seq2 as node()) as xs:boolean Whether two sequences contain the same XML nodes, regardless of order .
sequence-node-equal($seq1 as node(), $seq2 as node()) as xs:boolean Whether two sequences contain the same XML nodes, in the same order .
sequence-type($items as item()*) as xs:string The sequence type that represents a sequence of nodes or values .
siblings-same-name($element as element()?) as element()* The siblings of an XML element that have the same name .
siblings($node as node()?) as node()* The siblings of an XML node .
sort-as-numeric($seq as item()) as item() Sorts a sequence of numeric values or nodes .
sort-case-insensitive($seq as item()) as item() Sorts a sequence of values or nodes regardless of capitalization .
sort-document-order($seq as node()) as node() Sorts a sequence of nodes in document order .
sort($seq as item()) as item() Sorts a sequence of values or nodes .
substring-after-if-contains($arg as xs:string?, $delim as xs:string) as xs:string? Performs substring-after, returning the entire string if it does not contain the delimiter .
substring-after-last-match($arg as xs:string?, $regex as xs:string) as xs:string The substring after the last text that matches a regex .
substring-after-last($arg as xs:string?, $delim as xs:string) as xs:string The substring after the last occurrence of a delimiter .
substring-after-match($arg as xs:string?, $regex as xs:string) as xs:string? The substring after the first text that matches a regex .
substring-before-if-contains($arg as xs:string?, $delim as xs:string) as xs:string? Performs substring-before, returning the entire string if it does not contain the delimiter .
substring-before-last-match($arg as xs:string?, $regex as xs:string) as xs:string? The substring after the first text that matches a regex .
substring-before-last($arg as xs:string?, $delim as xs:string) as xs:string The substring before the last occurrence of a delimiter .
substring-before-match($arg as xs:string?, $regex as xs:string) as xs:string The substring before the last text that matches a regex .
time($hour as xs:anyAtomicType, $minute as xs:anyAtomicType, $second as xs:anyAtomicType) as xs:time Construct a time from an hour, minute and second .
timezone-from-duration($duration as xs:dayTimeDuration) as xs:string Converts an xs:dayTimeDuration into a timezone like "-05:00" or "Z" .
total-days-from-duration($duration as xs:dayTimeDuration?) as xs:decimal? The total number of days in a dayTimeDuration .
total-hours-from-duration($duration as xs:dayTimeDuration?) as xs:decimal? The total number of hours in a dayTimeDuration .
total-minutes-from-duration($duration as xs:dayTimeDuration?) as xs:decimal? The total number of minutes in a dayTimeDuration .
total-months-from-duration($duration as xs:yearMonthDuration?) as xs:decimal? The total number of months in a yearMonthDuration .
total-seconds-from-duration($duration as xs:dayTimeDuration?) as xs:decimal? The total number of seconds in a dayTimeDuration .
total-years-from-duration($duration as xs:yearMonthDuration?) as xs:decimal? The total number of years in a yearMonthDuration .
trim($arg as xs:string?) as xs:string Trims leading and trailing whitespace .
update-attributes($elements as element(), $attrNames as xs:QName, $attrValues as xs:anyAtomicType) as element(*)? Updates the attribute value of an XML element .
value-except($arg1 as xs:anyAtomicType, $arg2 as xs:anyAtomicType) as xs:anyAtomicType* The values in one sequence that aren't in another sequence .
value-intersect($arg1 as xs:anyAtomicType, $arg2 as xs:anyAtomicType) as xs:anyAtomicType* The intersection of two sequences of values .
value-union($arg1 as xs:anyAtomicType, $arg2 as xs:anyAtomicType) as xs:anyAtomicType* The union of two sequences of values .
word-count($arg as xs:string?) as xs:integer The number of words .
words-to-camel-case($arg as xs:string?) as xs:string Turns a string of words into camelCase .
wrap-values-in-elements($values as xs:anyAtomicType, $elementName as xs:QName) as element()* Wraps a sequence of atomic values in XML elements .
yearMonthDuration($years as xs:decimal?, $months as xs:integer?) as xs:yearMonthDuration Construct a yearMonthDuration from a number of years and months .

Functions

add-attributes#3

declare function functx:add-attributes(
    $elements as element(*)*,
    $attrNames as xs:QName*,
    $attrValues as xs:anyAtomicType*
) as element(*)?

Adds attributes to XML elements

Parameters

$elements
the element(s) to which you wish to add the attribute
$attrNames
the name(s) of the attribute(s) to add
$attrValues
the value(s) of the attribute(s) to add

Returns

element(*)?

add-months#2

declare function functx:add-months(
    $date as xs:anyAtomicType?,
    $months as xs:integer
) as xs:date?

Adds months to a date

Parameters

$date
the date
$months
the number of months to add

Returns

xs:date?

add-or-update-attributes#3

declare function functx:add-or-update-attributes(
    $elements as element(*)*,
    $attrNames as xs:QName*,
    $attrValues as xs:anyAtomicType*
) as element(*)?

Adds attributes to XML elements

Parameters

$elements
the element(s) to which you wish to add the attribute
$attrNames
the name(s) of the attribute(s) to add
$attrValues
the value(s) of the attribute(s) to add

Returns

element(*)?

all-whitespace#1

declare function functx:all-whitespace(
    $arg as xs:string?
) as xs:boolean

Whether a value is all whitespace or a zero-length string

Parameters

$arg
the string (or node) to test

Returns

xs:boolean

are-distinct-values#1

declare function functx:are-distinct-values(
    $seq as xs:anyAtomicType*
) as xs:boolean

Whether all the values in a sequence are distinct

Parameters

$seq
the sequence of values

Returns

xs:boolean

atomic-type#1

declare function functx:atomic-type(
    $values as xs:anyAtomicType*
) as xs:string*

The built-in type of an atomic value

Parameters

$values
the value(s) whose type you want to determine

Returns

xs:string*

avg-empty-is-zero#2

declare function functx:avg-empty-is-zero(
    $values as xs:anyAtomicType*,
    $allNodes as node()*
) as xs:double

The average, counting "empty" values as zero

Parameters

$values
the values to be averaged
$allNodes
the sequence of all nodes to find the average over

Returns

xs:double

between-exclusive#3

declare function functx:between-exclusive(
    $value as xs:anyAtomicType?,
    $minValue as xs:anyAtomicType,
    $maxValue as xs:anyAtomicType
) as xs:boolean

Whether a value is between two provided values

Parameters

$value
the value to be tested
$minValue
the minimum value
$maxValue
the maximum value

Returns

xs:boolean

between-inclusive#3

declare function functx:between-inclusive(
    $value as xs:anyAtomicType?,
    $minValue as xs:anyAtomicType,
    $maxValue as xs:anyAtomicType
) as xs:boolean

Whether a value is between two provided values, or equal to one of them

Parameters

$value
the value to be tested
$minValue
the minimum value
$maxValue
the maximum value

Returns

xs:boolean

camel-case-to-words#2

declare function functx:camel-case-to-words(
    $arg as xs:string?,
    $delim as xs:string
) as xs:string

Turns a camelCase string into space-separated words

Parameters

$arg
the string to modify
$delim
the delimiter for the words (e.g. a space)

Returns

xs:string

capitalize-first#1

declare function functx:capitalize-first(
    $arg as xs:string?
) as xs:string?

Capitalizes the first character of a string

Parameters

$arg
the word or phrase to capitalize

Returns

xs:string?

change-element-names-deep#3

declare function functx:change-element-names-deep(
    $nodes as node()*,
    $oldNames as xs:QName*,
    $newNames as xs:QName*
) as node()*

Changes the names of elements in an XML fragment

Parameters

$nodes
the element(s) to change
$oldNames
the sequence of names to change from
$newNames
the sequence of names to change to

Returns

node()*

change-element-ns-deep#3

declare function functx:change-element-ns-deep(
    $nodes as node()*,
    $newns as xs:string,
    $prefix as xs:string
) as node()*

Changes the namespace of XML elements and its descendants

Parameters

$nodes
the nodes to change
$newns
the new namespace
$prefix
the prefix to use for the new namespace

Returns

node()*

change-element-ns#3

declare function functx:change-element-ns(
    $elements as element(*)*,
    $newns as xs:string,
    $prefix as xs:string
) as element(*)?

Changes the namespace of XML elements

Parameters

$elements
the elements to change
$newns
the new namespace
$prefix
the prefix to use for the new namespace

Returns

element(*)?

chars#1

declare function functx:chars(
    $arg as xs:string?
) as xs:string*

Converts a string to a sequence of characters

Parameters

$arg
the string to split

Returns

xs:string*

contains-any-of#2

declare function functx:contains-any-of(
    $arg as xs:string?,
    $searchStrings as xs:string*
) as xs:boolean

Whether a string contains any of a sequence of strings

Parameters

$arg
the string to test
$searchStrings
the strings to look for

Returns

xs:boolean

contains-case-insensitive#2

declare function functx:contains-case-insensitive(
    $arg as xs:string?,
    $substring as xs:string
) as xs:boolean?

Whether one string contains another, without regard to case

Parameters

$arg
the string to search
$substring
the substring to find

Returns

xs:boolean?

contains-word#2

declare function functx:contains-word(
    $arg as xs:string?,
    $word as xs:string
) as xs:boolean

Whether one string contains another, as a separate word

Parameters

$arg
the string to search
$word
the word to find

Returns

xs:boolean

copy-attributes#2

declare function functx:copy-attributes(
    $copyTo as element(*),
    $copyFrom as element(*)
) as element(*)

Copies attributes from one element to another

Parameters

$copyTo
the element to copy attributes to
$copyFrom
the element to copy attributes from

Returns

element(*)

date#3

declare function functx:date(
    $year as xs:anyAtomicType,
    $month as xs:anyAtomicType,
    $day as xs:anyAtomicType
) as xs:date

Construct a date from a year, month and day

Parameters

$year
the year
$month
the month
$day
the day

Returns

xs:date

dateTime#6

declare function functx:dateTime(
    $year as xs:anyAtomicType,
    $month as xs:anyAtomicType,
    $day as xs:anyAtomicType,
    $hour as xs:anyAtomicType,
    $minute as xs:anyAtomicType,
    $second as xs:anyAtomicType
) as xs:dateTime

Construct a date/time from individual components

Parameters

$year
the year
$month
the month
$day
the day
$hour
the hour
$minute
the minute
$second
the second

Returns

xs:dateTime

day-in-year#1

declare function functx:day-in-year(
    $date as xs:anyAtomicType?
) as xs:integer?

The day of the year (a number between 1 and 366)

Parameters

$date
the date

Returns

xs:integer?

day-of-week-abbrev-en#1

declare function functx:day-of-week-abbrev-en(
    $date as xs:anyAtomicType?
) as xs:string?

The abbreviated day of the week, from a date, in English

Parameters

$date
the date

Returns

xs:string?

day-of-week-name-en#1

declare function functx:day-of-week-name-en(
    $date as xs:anyAtomicType?
) as xs:string?

The name of the day of the week, from a date, in English

Parameters

$date
the date

Returns

xs:string?

day-of-week#1

declare function functx:day-of-week(
    $date as xs:anyAtomicType?
) as xs:integer?

The day of the week, from a date

Parameters

$date
the date

Returns

xs:integer?

dayTimeDuration#4

declare function functx:dayTimeDuration(
    $days as xs:decimal?,
    $hours as xs:decimal?,
    $minutes as xs:decimal?,
    $seconds as xs:decimal?
) as xs:dayTimeDuration

Construct a dayTimeDuration from a number of days, hours, etc.

Parameters

$days
the number of days
$hours
the number of hours
$minutes
the number of minutes
$seconds
the number of seconds

Returns

xs:dayTimeDuration

days-in-month#1

declare function functx:days-in-month(
    $date as xs:anyAtomicType?
) as xs:integer?

Number of days in the month

Parameters

$date
the date

Returns

xs:integer?

depth-of-node#1

declare function functx:depth-of-node(
    $node as node()?
) as xs:integer

The depth (level) of a node in an XML tree

Parameters

$node
the node to check

Returns

xs:integer

distinct-attribute-names#1

declare function functx:distinct-attribute-names(
    $nodes as node()*
) as xs:string*

The distinct names of all attributes in an XML fragment

Parameters

$nodes
the root to start from

Returns

xs:string*

distinct-deep#1

declare function functx:distinct-deep(
    $nodes as node()*
) as node()*

The XML nodes with distinct values, taking into account attributes and descendants

Parameters

$nodes
the sequence of nodes to test

Returns

node()*

distinct-element-names#1

declare function functx:distinct-element-names(
    $nodes as node()*
) as xs:string*

The distinct names of all elements in an XML fragment

Parameters

$nodes
the root(s) to start from

Returns

xs:string*

distinct-element-paths#1

declare function functx:distinct-element-paths(
    $nodes as node()*
) as xs:string*

The distinct paths of all descendant elements in an XML fragment

Parameters

$nodes
the root(s) to start from

Returns

xs:string*

distinct-nodes#1

declare function functx:distinct-nodes(
    $nodes as node()*
) as node()*

The distinct XML nodes in a sequence (by node identity)

Parameters

$nodes
the node sequence

Returns

node()*

duration-from-timezone#1

declare function functx:duration-from-timezone(
    $timezone as xs:string
) as xs:dayTimeDuration

Converts a timezone like "-05:00" or "Z" into xs:dayTimeDuration

Parameters

$timezone
the time zone, in (+|-)HH:MM format

Returns

xs:dayTimeDuration

dynamic-path#2

declare function functx:dynamic-path(
    $parent as node(),
    $path as xs:string
) as item()*

Dynamically evaluates a simple XPath path

Parameters

$parent
the root to start from
$path
the path expression

Returns

item()*

escape-for-regex#1

declare function functx:escape-for-regex(
    $arg as xs:string?
) as xs:string

Escapes regex special characters

Parameters

$arg
the string to escape

Returns

xs:string

exclusive-or#2

declare function functx:exclusive-or(
    $arg1 as xs:boolean?,
    $arg2 as xs:boolean?
) as xs:boolean?

Whether one (and only one) of two boolean values is true

Parameters

$arg1
the first boolean value
$arg2
the second boolean value

Returns

xs:boolean?

first-day-of-month#1

declare function functx:first-day-of-month(
    $date as xs:anyAtomicType?
) as xs:date?

The first day of the month of a date

Parameters

$date
the date

Returns

xs:date?

first-day-of-year#1

declare function functx:first-day-of-year(
    $date as xs:anyAtomicType?
) as xs:date?

The first day of the year of a date

Parameters

$date
the date

Returns

xs:date?

first-node#1

declare function functx:first-node(
    $nodes as node()*
) as node()?

The XML node in a sequence that appears first in document order

Parameters

$nodes
the sequence of nodes

Returns

node()?

follows-not-descendant#2

declare function functx:follows-not-descendant(
    $a as node()?,
    $b as node()?
) as xs:boolean

Whether an XML node follows another without being its descendant

Parameters

$a
the first node
$b
the second node

Returns

xs:boolean

format-as-title-en#1

declare function functx:format-as-title-en(
    $titles as xs:string*
) as xs:string*

Moves title words like "the" and "a" to the end of strings

Parameters

$titles
the titles to format

Returns

xs:string*

fragment-from-uri#1

declare function functx:fragment-from-uri(
    $uri as xs:string?
) as xs:string?

Returns the fragment from a URI

Parameters

$uri
the URI

Returns

xs:string?

get-matches-and-non-matches#2

declare function functx:get-matches-and-non-matches(
    $string as xs:string?,
    $regex as xs:string
) as element(*)*

Splits a string into matching and non-matching regions

Parameters

$string
the string to split
$regex
the pattern

Returns

element(*)*

get-matches#2

declare function functx:get-matches(
    $string as xs:string?,
    $regex as xs:string
) as xs:string*

Return the matching regions of a string

Parameters

$string
the string to split
$regex
the pattern

Returns

xs:string*

has-element-only-content#1

declare function functx:has-element-only-content(
    $element as element(*)
) as xs:boolean

Whether an element has element-only content

Parameters

$element
the XML element to test

Returns

xs:boolean

has-empty-content#1

declare function functx:has-empty-content(
    $element as element(*)
) as xs:boolean

Whether an element has empty content

Parameters

$element
the XML element to test

Returns

xs:boolean

has-mixed-content#1

declare function functx:has-mixed-content(
    $element as element(*)
) as xs:boolean

Whether an element has mixed content

Parameters

$element
the XML element to test

Returns

xs:boolean

has-simple-content#1

declare function functx:has-simple-content(
    $element as element(*)
) as xs:boolean

Whether an element has simple content

Parameters

$element
the XML element to test

Returns

xs:boolean

id-from-element#1

declare function functx:id-from-element(
    $element as element(*)?
) as xs:string?

Gets the ID of an XML element

Parameters

$element
the element

Returns

xs:string?

id-untyped#2

declare function functx:id-untyped(
    $node as node()*,
    $id as xs:anyAtomicType
) as element(*)*

Gets XML element(s) that have an attribute with a particular value

Parameters

$node
the root node(s) to start from
$id
the "id" to find

Returns

element(*)*

if-absent#2

declare function functx:if-absent(
    $arg as item()*,
    $value as item()*
) as item()*

The first argument if it is not empty, otherwise the second argument

Parameters

$arg
the item(s) that may be absent
$value
the item(s) to use if the item is absent

Returns

item()*

if-empty#2

declare function functx:if-empty(
    $arg as item()?,
    $value as item()*
) as item()*

The first argument if it is not blank, otherwise the second argument

Parameters

$arg
the node that may be empty
$value
the item(s) to use if the node is empty

Returns

item()*

index-of-deep-equal-node#2

declare function functx:index-of-deep-equal-node(
    $nodes as node()*,
    $nodeToFind as node()
) as xs:integer*

The position of a node in a sequence, based on contents and attributes

Parameters

$nodes
the node sequence
$nodeToFind
the node to find in the sequence

Returns

xs:integer*

index-of-match-first#2

declare function functx:index-of-match-first(
    $arg as xs:string?,
    $pattern as xs:string
) as xs:integer?

The first position of a matching substring

Parameters

$arg
the string
$pattern
the pattern to match

Returns

xs:integer?

index-of-node#2

declare function functx:index-of-node(
    $nodes as node()*,
    $nodeToFind as node()
) as xs:integer*

The position of a node in a sequence, based on node identity

Parameters

$nodes
the node sequence
$nodeToFind
the node to find in the sequence

Returns

xs:integer*

index-of-string-first#2

declare function functx:index-of-string-first(
    $arg as xs:string?,
    $substring as xs:string
) as xs:integer?

The first position of a substring

Parameters

$arg
the string
$substring
the substring to find

Returns

xs:integer?

index-of-string-last#2

declare function functx:index-of-string-last(
    $arg as xs:string?,
    $substring as xs:string
) as xs:integer?

The last position of a substring

Parameters

$arg
the string
$substring
the substring to find

Returns

xs:integer?

index-of-string#2

declare function functx:index-of-string(
    $arg as xs:string?,
    $substring as xs:string
) as xs:integer*

The position(s) of a substring

Parameters

$arg
the string
$substring
the substring to find

Returns

xs:integer*

insert-string#3

declare function functx:insert-string(
    $originalString as xs:string?,
    $stringToInsert as xs:string?,
    $pos as xs:integer
) as xs:string

Inserts a string at a specified position

Parameters

$originalString
the original string to insert into
$stringToInsert
the string to insert
$pos
the position

Returns

xs:string

is-a-number#1

declare function functx:is-a-number(
    $value as xs:anyAtomicType?
) as xs:boolean

Whether a value is numeric

Parameters

$value
the value to test

Returns

xs:boolean

is-absolute-uri#1

declare function functx:is-absolute-uri(
    $uri as xs:string?
) as xs:boolean

Whether a URI is absolute

Parameters

$uri
the URI to test

Returns

xs:boolean

is-ancestor#2

declare function functx:is-ancestor(
    $node1 as node(),
    $node2 as node()
) as xs:boolean

Whether an XML node is an ancestor of another node

Parameters

$node1
the first node
$node2
the second node

Returns

xs:boolean

is-descendant#2

declare function functx:is-descendant(
    $node1 as node(),
    $node2 as node()
) as xs:boolean

Whether an XML node is a descendant of another node

Parameters

$node1
the first node
$node2
the second node

Returns

xs:boolean

is-leap-year#1

declare function functx:is-leap-year(
    $date as xs:anyAtomicType?
) as xs:boolean

Whether a date falls in a leap year

Parameters

$date
the date or year

Returns

xs:boolean

is-node-among-descendants-deep-equal#2

declare function functx:is-node-among-descendants-deep-equal(
    $node as node()?,
    $seq as node()*
) as xs:boolean

Whether an XML node is among the descendants of a sequence, based on contents and attributes

Parameters

$node
the node to test
$seq
the sequence of nodes to search

Returns

xs:boolean

is-node-among-descendants#2

declare function functx:is-node-among-descendants(
    $node as node()?,
    $seq as node()*
) as xs:boolean

Whether an XML node is among the descendants of a sequence, based on node identity

Parameters

$node
the node to test
$seq
the sequence of nodes to search

Returns

xs:boolean

is-node-in-sequence-deep-equal#2

declare function functx:is-node-in-sequence-deep-equal(
    $node as node()?,
    $seq as node()*
) as xs:boolean

Whether an XML node is in a sequence, based on contents and attributes

Parameters

$node
the node to test
$seq
the sequence of nodes to search

Returns

xs:boolean

is-node-in-sequence#2

declare function functx:is-node-in-sequence(
    $node as node()?,
    $seq as node()*
) as xs:boolean

Whether an XML node is in a sequence, based on node identity

Parameters

$node
the node to test
$seq
the sequence of nodes to search

Returns

xs:boolean

is-value-in-sequence#2

declare function functx:is-value-in-sequence(
    $value as xs:anyAtomicType?,
    $seq as xs:anyAtomicType*
) as xs:boolean

Whether an atomic value appears in a sequence

Parameters

$value
the atomic value to test
$seq
the sequence of values to search

Returns

xs:boolean

last-day-of-month#1

declare function functx:last-day-of-month(
    $date as xs:anyAtomicType?
) as xs:date?

The last day of the month of a date

Parameters

$date
the date

Returns

xs:date?

last-day-of-year#1

declare function functx:last-day-of-year(
    $date as xs:anyAtomicType?
) as xs:date?

The last day of the month of a date

Parameters

$date
the date

Returns

xs:date?

last-node#1

declare function functx:last-node(
    $nodes as node()*
) as node()?

The XML node in a sequence that is last in document order

Parameters

$nodes
the sequence of nodes

Returns

node()?

leaf-elements#1

declare function functx:leaf-elements(
    $root as node()?
) as element(*)*

All XML elements that don't have any child elements

Parameters

$root
the root

Returns

element(*)*

left-trim#1

declare function functx:left-trim(
    $arg as xs:string?
) as xs:string

Trims leading whitespace

Parameters

$arg
the string to trim

Returns

xs:string

line-count#1

declare function functx:line-count(
    $arg as xs:string?
) as xs:integer

The number of lines

Parameters

$arg
the string to test

Returns

xs:integer

lines#1

declare function functx:lines(
    $arg as xs:string?
) as xs:string*

Split a string into separate lines

Parameters

$arg
the string to split

Returns

xs:string*

max-depth#1

declare function functx:max-depth(
    $root as node()?
) as xs:integer?

The maximum depth of elements in an XML tree

Parameters

$root
the root to start from

Returns

xs:integer?

max-determine-type#1

declare function functx:max-determine-type(
    $seq as xs:anyAtomicType*
) as xs:anyAtomicType?

The maximum value in a sequence, figuring out its type (numeric or string)

Parameters

$seq
the sequence of values to test

Returns

xs:anyAtomicType?

max-line-length#1

declare function functx:max-line-length(
    $arg as xs:string?
) as xs:integer

The maximum line length

Parameters

$arg
the string to test

Returns

xs:integer

max-node#1

declare function functx:max-node(
    $nodes as node()*
) as node()*

The XML node whose typed value is the maximum

Parameters

$nodes
the sequence of nodes to test

Returns

node()*

max-string#1

declare function functx:max-string(
    $strings as xs:anyAtomicType*
) as xs:string?

The maximum of a sequence of values, treating them like strings

Parameters

$strings
the sequence of values

Returns

xs:string?

min-determine-type#1

declare function functx:min-determine-type(
    $seq as xs:anyAtomicType*
) as xs:anyAtomicType?

The minimum value in a sequence, figuring out its type (numeric or string)

Parameters

$seq
the sequence of values to test

Returns

xs:anyAtomicType?

min-node#1

declare function functx:min-node(
    $nodes as node()*
) as node()*

The XML node whose typed value is the minimum

Parameters

$nodes
the sequence of nodes to test

Returns

node()*

min-non-empty-string#1

declare function functx:min-non-empty-string(
    $strings as xs:string*
) as xs:string?

The minimum of a sequence of strings, ignoring "empty" values

Parameters

$strings
the sequence of strings to search

Returns

xs:string?

min-string#1

declare function functx:min-string(
    $strings as xs:anyAtomicType*
) as xs:string?

The minimum of a sequence of values, treating them like strings

Parameters

$strings
the sequence of strings

Returns

xs:string?

mmddyyyy-to-date#1

declare function functx:mmddyyyy-to-date(
    $dateString as xs:string?
) as xs:date?

Converts a string with format MMDDYYYY (with any delimiters) to a date

Parameters

$dateString
the MMDDYYYY string

Returns

xs:date?

month-abbrev-en#1

declare function functx:month-abbrev-en(
    $date as xs:anyAtomicType?
) as xs:string?

The month of a date as an abbreviated word (Jan, Feb, etc.)

Parameters

$date
the date

Returns

xs:string?

month-name-en#1

declare function functx:month-name-en(
    $date as xs:anyAtomicType?
) as xs:string?

The month of a date as a word (January, February, etc.)

Parameters

$date
the date

Returns

xs:string?

name-test#2

declare function functx:name-test(
    $testname as xs:string?,
    $names as xs:string*
) as xs:boolean

Whether a name matches a list of names or name wildcards

Parameters

$testname
the name to test
$names
the list of names or name wildcards

Returns

xs:boolean

namespaces-in-use#1

declare function functx:namespaces-in-use(
    $root as node()?
) as xs:anyURI*

A list of namespaces used in element/attribute names in an XML fragment

Parameters

$root
the root node to start from

Returns

xs:anyURI*

next-day#1

declare function functx:next-day(
    $date as xs:anyAtomicType?
) as xs:date?

The next day

Parameters

$date
the date

Returns

xs:date?

node-kind#1

declare function functx:node-kind(
    $nodes as node()*
) as xs:string*

The XML node kind (element, attribute, text, etc.)

Parameters

$nodes
the node(s) whose kind you want to determine

Returns

xs:string*

non-distinct-values#1

declare function functx:non-distinct-values(
    $seq as xs:anyAtomicType*
) as xs:anyAtomicType*

Returns any values that appear more than once in a sequence

Parameters

$seq
the sequence of values

Returns

xs:anyAtomicType*

number-of-matches#2

declare function functx:number-of-matches(
    $arg as xs:string?,
    $pattern as xs:string
) as xs:integer

The number of regions that match a pattern

Parameters

$arg
the string to test
$pattern
the regular expression

Returns

xs:integer

open-ref-document#1

declare function functx:open-ref-document(
    $refNode as node()
) as document()

Resolves a relative URI and references it, returning an XML document

Parameters

$refNode
a node whose value is a relative URI reference

Returns

document()

ordinal-number-en#1

declare function functx:ordinal-number-en(
    $num as xs:integer?
) as xs:string

Reformats a number as an ordinal number, e.g. 1st, 2nd, 3rd.

Parameters

$num
the number

Returns

xs:string

pad-integer-to-length#2

declare function functx:pad-integer-to-length(
    $integerToPad as xs:anyAtomicType?,
    $length as xs:integer
) as xs:string

Pads an integer to a desired length by adding leading zeros

Parameters

$integerToPad
the integer to pad
$length
the desired length

Returns

xs:string

pad-string-to-length#3

declare function functx:pad-string-to-length(
    $stringToPad as xs:string?,
    $padChar as xs:string,
    $length as xs:integer
) as xs:string

Pads a string to a desired length

Parameters

$stringToPad
the string to pad
$padChar
the character(s) to use as padding
$length
the desired length

Returns

xs:string

path-to-node-with-pos#1

declare function functx:path-to-node-with-pos(
    $node as node()?
) as xs:string

A unique path to an XML node (or sequence of nodes)

Parameters

$node
the node sequence

Returns

xs:string

path-to-node#1

declare function functx:path-to-node(
    $nodes as node()*
) as xs:string*

A path to an XML node (or sequence of nodes)

Parameters

$nodes
the node sequence

Returns

xs:string*

precedes-not-ancestor#2

declare function functx:precedes-not-ancestor(
    $a as node()?,
    $b as node()?
) as xs:boolean

Whether an XML node precedes another without being its ancestor

Parameters

$a
the first node
$b
the second node

Returns

xs:boolean

previous-day#1

declare function functx:previous-day(
    $date as xs:anyAtomicType?
) as xs:date?

The previous day

Parameters

$date
the date

Returns

xs:date?

remove-attributes-deep#2

declare function functx:remove-attributes-deep(
    $nodes as node()*,
    $names as xs:string*
) as node()*

Removes attributes from an XML fragment, based on name

Parameters

$nodes
the root(s) to start from
$names
the names of the attributes to remove, or * for all attributes

Returns

node()*

remove-attributes#2

declare function functx:remove-attributes(
    $elements as element(*)*,
    $names as xs:string*
) as element(*)

Removes attributes from an XML element, based on name

Parameters

$elements
the element(s) from which to remove the attributes
$names
the names of the attributes to remove, or * for all attributes

Returns

element(*)

remove-elements-deep#2

declare function functx:remove-elements-deep(
    $nodes as node()*,
    $names as xs:string*
) as node()*

Removes descendant elements from an XML node, based on name

Parameters

$nodes
root(s) to start from
$names
the names of the elements to remove

Returns

node()*

remove-elements-not-contents#2

declare function functx:remove-elements-not-contents(
    $nodes as node()*,
    $names as xs:string*
) as node()*

Removes descendant XML elements but keeps their content

Parameters

$nodes
the root(s) to start from
$names
the names of the elements to remove

Returns

node()*

remove-elements#2

declare function functx:remove-elements(
    $elements as element(*)*,
    $names as xs:string*
) as element(*)*

Removes child elements from an XML node, based on name

Parameters

$elements
the element(s) from which you wish to remove the children
$names
the names of the child elements to remove

Returns

element(*)*

repeat-string#2

declare function functx:repeat-string(
    $stringToRepeat as xs:string?,
    $count as xs:integer
) as xs:string

Repeats a string a given number of times

Parameters

$stringToRepeat
the string to repeat
$count
the desired number of copies

Returns

xs:string

replace-beginning#3

declare function functx:replace-beginning(
    $arg as xs:string?,
    $pattern as xs:string,
    $replacement as xs:string
) as xs:string

Replaces the beginning of a string, up to a matched pattern

Parameters

$arg
the entire string to change
$pattern
the pattern of characters to replace up to
$replacement
the replacement string

Returns

xs:string

replace-element-values#2

declare function functx:replace-element-values(
    $elements as element(*)*,
    $values as xs:anyAtomicType*
) as element(*)*

Updates the content of one or more elements

Parameters

$elements
the elements whose content you wish to replace
$values
the replacement values

Returns

element(*)*

replace-first#3

declare function functx:replace-first(
    $arg as xs:string?,
    $pattern as xs:string,
    $replacement as xs:string
) as xs:string

Replaces the first match of a pattern

Parameters

$arg
the entire string to change
$pattern
the pattern of characters to replace
$replacement
the replacement string

Returns

xs:string

replace-multi#3

declare function functx:replace-multi(
    $arg as xs:string?,
    $changeFrom as xs:string*,
    $changeTo as xs:string*
) as xs:string?

Performs multiple replacements, using pairs of replace parameters

Parameters

$arg
the string to manipulate
$changeFrom
the sequence of strings or patterns to change from
$changeTo
the sequence of strings to change to

Returns

xs:string?

reverse-string#1

declare function functx:reverse-string(
    $arg as xs:string?
) as xs:string

Reverses the order of characters

Parameters

$arg
the string to reverse

Returns

xs:string

right-trim#1

declare function functx:right-trim(
    $arg as xs:string?
) as xs:string

Trims trailing whitespace

Parameters

$arg
the string to trim

Returns

xs:string

scheme-from-uri#1

declare function functx:scheme-from-uri(
    $uri as xs:string?
) as xs:string?

Returns the scheme from a URI

Parameters

$uri
the URI

Returns

xs:string?

sequence-deep-equal#2

declare function functx:sequence-deep-equal(
    $seq1 as item()*,
    $seq2 as item()*
) as xs:boolean

Whether two sequences have the same XML node content and/or values

Parameters

$seq1
the first sequence
$seq2
the second sequence

Returns

xs:boolean

sequence-node-equal-any-order#2

declare function functx:sequence-node-equal-any-order(
    $seq1 as node()*,
    $seq2 as node()*
) as xs:boolean

Whether two sequences contain the same XML nodes, regardless of order

Parameters

$seq1
the first sequence of nodes
$seq2
the second sequence of nodes

Returns

xs:boolean

sequence-node-equal#2

declare function functx:sequence-node-equal(
    $seq1 as node()*,
    $seq2 as node()*
) as xs:boolean

Whether two sequences contain the same XML nodes, in the same order

Parameters

$seq1
the first sequence of nodes
$seq2
the second sequence of nodes

Returns

xs:boolean

sequence-type#1

declare function functx:sequence-type(
    $items as item()*
) as xs:string

The sequence type that represents a sequence of nodes or values

Parameters

$items
the items whose sequence type you want to determine

Returns

xs:string

siblings-same-name#1

declare function functx:siblings-same-name(
    $element as element(*)?
) as element(*)*

The siblings of an XML element that have the same name

Parameters

$element
the node

Returns

element(*)*

siblings#1

declare function functx:siblings(
    $node as node()?
) as node()*

The siblings of an XML node

Parameters

$node
the node

Returns

node()*

sort-as-numeric#1

declare function functx:sort-as-numeric(
    $seq as item()*
) as item()*

Sorts a sequence of numeric values or nodes

Parameters

$seq
the sequence to sort

Returns

item()*

sort-case-insensitive#1

declare function functx:sort-case-insensitive(
    $seq as item()*
) as item()*

Sorts a sequence of values or nodes regardless of capitalization

Parameters

$seq
the sequence to sort

Returns

item()*

sort-document-order#1

declare function functx:sort-document-order(
    $seq as node()*
) as node()*

Sorts a sequence of nodes in document order

Parameters

$seq
the sequence to sort

Returns

node()*

sort#1

declare function functx:sort(
    $seq as item()*
) as item()*

Sorts a sequence of values or nodes

Parameters

$seq
the sequence to sort

Returns

item()*

substring-after-if-contains#2

declare function functx:substring-after-if-contains(
    $arg as xs:string?,
    $delim as xs:string
) as xs:string?

Performs substring-after, returning the entire string if it does not contain the delimiter

Parameters

$arg
the string to substring
$delim
the delimiter

Returns

xs:string?

substring-after-last-match#2

declare function functx:substring-after-last-match(
    $arg as xs:string?,
    $regex as xs:string
) as xs:string

The substring after the last text that matches a regex

Parameters

$arg
the string to substring
$regex
the regular expression

Returns

xs:string

substring-after-last#2

declare function functx:substring-after-last(
    $arg as xs:string?,
    $delim as xs:string
) as xs:string

The substring after the last occurrence of a delimiter

Parameters

$arg
the string to substring
$delim
the delimiter

Returns

xs:string

substring-after-match#2

declare function functx:substring-after-match(
    $arg as xs:string?,
    $regex as xs:string
) as xs:string?

The substring after the first text that matches a regex

Parameters

$arg
the string to substring
$regex
the regular expression

Returns

xs:string?

substring-before-if-contains#2

declare function functx:substring-before-if-contains(
    $arg as xs:string?,
    $delim as xs:string
) as xs:string?

Performs substring-before, returning the entire string if it does not contain the delimiter

Parameters

$arg
the string to substring
$delim
the delimiter

Returns

xs:string?

substring-before-last-match#2

declare function functx:substring-before-last-match(
    $arg as xs:string?,
    $regex as xs:string
) as xs:string?

The substring after the first text that matches a regex

Parameters

$arg
the string to substring
$regex
the regular expression

Returns

xs:string?

substring-before-last#2

declare function functx:substring-before-last(
    $arg as xs:string?,
    $delim as xs:string
) as xs:string

The substring before the last occurrence of a delimiter

Parameters

$arg
the string to substring
$delim
the delimiter

Returns

xs:string

substring-before-match#2

declare function functx:substring-before-match(
    $arg as xs:string?,
    $regex as xs:string
) as xs:string

The substring before the last text that matches a regex

Parameters

$arg
the string to substring
$regex
the regular expression

Returns

xs:string

time#3

declare function functx:time(
    $hour as xs:anyAtomicType,
    $minute as xs:anyAtomicType,
    $second as xs:anyAtomicType
) as xs:time

Construct a time from an hour, minute and second

Parameters

$hour
the hour
$minute
the minute
$second
the second

Returns

xs:time

timezone-from-duration#1

declare function functx:timezone-from-duration(
    $duration as xs:dayTimeDuration
) as xs:string

Converts an xs:dayTimeDuration into a timezone like "-05:00" or "Z"

Parameters

$duration
the duration

Returns

xs:string

total-days-from-duration#1

declare function functx:total-days-from-duration(
    $duration as xs:dayTimeDuration?
) as xs:decimal?

The total number of days in a dayTimeDuration

Parameters

$duration
the duration

Returns

xs:decimal?

total-hours-from-duration#1

declare function functx:total-hours-from-duration(
    $duration as xs:dayTimeDuration?
) as xs:decimal?

The total number of hours in a dayTimeDuration

Parameters

$duration
the duration

Returns

xs:decimal?

total-minutes-from-duration#1

declare function functx:total-minutes-from-duration(
    $duration as xs:dayTimeDuration?
) as xs:decimal?

The total number of minutes in a dayTimeDuration

Parameters

$duration
the duration

Returns

xs:decimal?

total-months-from-duration#1

declare function functx:total-months-from-duration(
    $duration as xs:yearMonthDuration?
) as xs:decimal?

The total number of months in a yearMonthDuration

Parameters

$duration
the duration

Returns

xs:decimal?

total-seconds-from-duration#1

declare function functx:total-seconds-from-duration(
    $duration as xs:dayTimeDuration?
) as xs:decimal?

The total number of seconds in a dayTimeDuration

Parameters

$duration
the duration

Returns

xs:decimal?

total-years-from-duration#1

declare function functx:total-years-from-duration(
    $duration as xs:yearMonthDuration?
) as xs:decimal?

The total number of years in a yearMonthDuration

Parameters

$duration
the duration

Returns

xs:decimal?

trim#1

declare function functx:trim(
    $arg as xs:string?
) as xs:string

Trims leading and trailing whitespace

Parameters

$arg
the string to trim

Returns

xs:string

update-attributes#3

declare function functx:update-attributes(
    $elements as element(*)*,
    $attrNames as xs:QName*,
    $attrValues as xs:anyAtomicType*
) as element(*)?

Updates the attribute value of an XML element

Parameters

$elements
the element(s) for which you wish to update the attribute
$attrNames
the name(s) of the attribute(s) to add
$attrValues
the value(s) of the attribute(s) to add

Returns

element(*)?

value-except#2

declare function functx:value-except(
    $arg1 as xs:anyAtomicType*,
    $arg2 as xs:anyAtomicType*
) as xs:anyAtomicType*

The values in one sequence that aren't in another sequence

Parameters

$arg1
the first sequence
$arg2
the second sequence

Returns

xs:anyAtomicType*

value-intersect#2

declare function functx:value-intersect(
    $arg1 as xs:anyAtomicType*,
    $arg2 as xs:anyAtomicType*
) as xs:anyAtomicType*

The intersection of two sequences of values

Parameters

$arg1
the first sequence
$arg2
the second sequence

Returns

xs:anyAtomicType*

value-union#2

declare function functx:value-union(
    $arg1 as xs:anyAtomicType*,
    $arg2 as xs:anyAtomicType*
) as xs:anyAtomicType*

The union of two sequences of values

Parameters

$arg1
the first sequence
$arg2
the second sequence

Returns

xs:anyAtomicType*

word-count#1

declare function functx:word-count(
    $arg as xs:string?
) as xs:integer

The number of words

Parameters

$arg
the string to measure

Returns

xs:integer

words-to-camel-case#1

declare function functx:words-to-camel-case(
    $arg as xs:string?
) as xs:string

Turns a string of words into camelCase

Parameters

$arg
the string to modify

Returns

xs:string

wrap-values-in-elements#2

declare function functx:wrap-values-in-elements(
    $values as xs:anyAtomicType*,
    $elementName as xs:QName
) as element(*)*

Wraps a sequence of atomic values in XML elements

Parameters

$values
the values to wrap in elements
$elementName
the name of the elements to construct

Returns

element(*)*

yearMonthDuration#2

declare function functx:yearMonthDuration(
    $years as xs:decimal?,
    $months as xs:integer?
) as xs:yearMonthDuration

Construct a yearMonthDuration from a number of years and months

Parameters

$years
the number of years
$months
the number of months

Returns

xs:yearMonthDuration

http://www.functx.com

Description

Module code

See also

Version Declaration

Namespaces

Function Summary

Functions

add-attributes#3

Parameters

Returns

add-months#2

Parameters

Returns

add-or-update-attributes#3

Parameters

Returns

all-whitespace#1

Parameters

Returns

are-distinct-values#1

Parameters

Returns

atomic-type#1

Parameters

Returns

avg-empty-is-zero#2

Parameters

Returns

between-exclusive#3

Parameters

Returns

between-inclusive#3

Parameters

Returns

camel-case-to-words#2

Parameters

Returns

capitalize-first#1

Parameters

Returns

change-element-names-deep#3

Parameters

Returns

change-element-ns-deep#3

Parameters

Returns

change-element-ns#3

Parameters

Returns

chars#1

Parameters

Returns

contains-any-of#2

Parameters

Returns

contains-case-insensitive#2

Parameters

Returns

contains-word#2

Parameters

Returns

copy-attributes#2

Parameters

Returns

date#3

Parameters

Returns

dateTime#6

Parameters

Returns

day-in-year#1

Parameters

Returns

day-of-week-abbrev-en#1

Parameters

Returns

day-of-week-name-en#1

Parameters

Returns