| A le B | xs:dateTime | xs:dateTime | fn:not(op:dateTime-greater-than(A, B)) | xs:boolean |
| A le B | xs:yearMonthDuration | xs:yearMonthDuration | fn:not(op:yearMonthDuration-greater-than(A, B)) | xs:boolean |
| A le B | xs:dayTimeDuration | xs:dayTimeDuration | fn:not(op:dayTimeDuration-greater-than(A, B)) | xs:boolean |
| A le B | xs:anyURI | xs:anyURI | op:numeric-less-than(fn:compare(A, B), 1) | xs:boolean |
| A is B | node() | node() | op:is-same-node(A, B) | xs:boolean |
| A << B | node() | node() | op:node-before(A, B) | xs:boolean |
| A >> B | node() | node() | op:node-after(A, B) | xs:boolean |
| A union B | node()* | node()* | op:union(A, B) | node()* |
| A | B | node()* | node()* | op:union(A, B) | node()* |
| A intersect B | node()* | node()* | op:intersect(A, B) | node()* |
| A except B | node()* | node()* | op:except(A, B) | node()* |
| A to B | xs:integer | xs:integer | op:to(A, B) | xs:integer* |
| A , B | item()* | item()* | op:concatenate(A, B) | item()* |
| A || B | xs:anyAtomicType | xs:anyAtomicType | fn:concat(A, B) | xs:string |
| Operator | Operand type | Function | Result type |
|---|---|---|---|
| + A | numeric | op:numeric-unary-plus(A) | numeric |
| - A | numeric | op:numeric-unary-minus(A) | numeric |
The tables in this section describe the scope (range of applicability) of the various components in a module's static context and dynamic context.
The following table describes the components of the static context. For each component, "global" indicates that the value of the component applies throughout an XPath expression, whereas "lexical" indicates that the value of the component applies only within the subexpression in which it is defined.
| Component | Scope |
|---|---|
| XPath 1.0 Compatibility Mode | global |
| Statically known namespaces | global |
| Default element/type namespace | global |
| Default function namespace | global |
| In-scope schema types | global |
| In-scope element declarations | global |
| In-scope attribute declarations | global |
| In-scope variables | lexical; for-expressions, let-expressions, and quantified expressions can bind new variables |
| Context item static type | lexical |
| Statically known function signatures | global |
| Statically known collations | global |
| Default collation | global |
| Base URI | global |
| Statically known documents | global |
| Statically known collections | global |
| Statically known default collection type | global |
The following table describes how values are assigned to the various components of the dynamic context. All these components are initialized by mechanisms defined by the host language. For each component, "global" indicates that the value of the component remains constant throughout evaluation of the XPath expression, whereas "dynamic" indicates that the value of the component can be modified by the evaluation of subexpressions.
| Component | Scope |
|---|---|
| Context item | dynamic; changes during evaluation of path expressions and predicates |
| Context position | dynamic; changes during evaluation of path expressions and predicates |
| Context size | dynamic; changes during evaluation of path expressions and predicates |
| Variable values | dynamic; for-expressions, let-expressions, and quantified expressions can bind new variables |
| Current date and time | global; must be initialized |
| Implicit timezone | global; must be initialized |
| Available documents | global; must be initialized |
| Available node collections | global; must be initialized |
| Default node collection | global; overwriteable by implementation |
| Available resource collections | global; must be initialized |
| Default resource collection | global; overwriteable by implementation |
The following items in this specification are implementation-defined:
The version of Unicode that is used to construct expressions.
The implicit timezone.
The circumstances in which warnings are raised, and the ways in which warnings are handled.
The method by which errors are reported to the external processing environment.
Which version of XML and XML Names (e.g. [XML 1.0] and [XML Names] or [XML 1.1] and [XML Names 1.1]) and which version of XML Schema (e.g. [XML Schema 1.0] or [XML Schema 1.1]) is used for the definitions of primitives such as characters and names, and for the definitions of operations such as normalization of line endings and normalization of whitespace in attribute values. It is recommended that the latest applicable version be used (even if it is published later than this specification).
How XDM instances are created from sources other than an Infoset or PSVI.
Whether the implementation supports the namespace axis.
Whether the type system is based on [XML Schema 1.0] or [XML Schema 1.1]. An implementation that has based its type system on XML Schema 1.0 is not required to support the use of the xs:dateTimeStamp constructor or the use of xs:dateTimeStamp as TypeName in any expression.
The signatures of functions provided by the implementation or via an implementation-defined API (see 2.1.1 Static Context).
Any environment variables provided by the implementation.
Any rules used for static typing (see <IP_ADDRESS> Static Analysis Phase).
Any serialization parameters provided by the implementationn
What error, if any, is returned if an external function's implementation does not return the declared result type (see 2.2.4 Consistency Constraints).
Note:
Additional implementation-defined items are listed in [XQuery and XPath Data Model (XDM) 3.0] and [XQuery and XPath Functions and Operators 3.0].
XPath is intended primarily as a component that can be used by other specifications. Therefore, XPath relies on specifications that use it (such as [XPointer] and [XSL Transformations (XSLT) Version 3.0]) to specify conformance criteria for XPath in their respective environments. Specifications that set conformance criteria for their use of XPath must not change the syntactic or semantic definitions of XPath as given in this specification, except by subsetting and/or compatible extensions.
The specification of such a language may describe it as an extension of XPath provided that every expression that conforms to the XPath grammar behaves as described in this specification.
[Definition: The Static Typing Feature is an optional feature of XPath that provides support for static semantics, and requires implementations to detect and report type errors during the static analysis phase.] Specifications that use XPath may specify conformance criteria for use of the Static Typing Feature.
If an implementation does not support the Static Typing Feature, but can nevertheless determine during the static analysis phase that an XPath expression, if evaluated, would necessarily raise a dynamic error or that an expression, if evaluated, would necessarily raise a type error, the implementation may raise that error during the static analysis phase. The choice of whether to raise such an error at analysis time is implementation dependent.
It is a static error if analysis of an expression relies on some component of the static context that is absentDM30 .
It is a dynamic error if evaluation of an expression relies on some part of the dynamic context that is absentDM30 .
It is a static error if an expression is not a valid instance of the grammar defined in A.1 EBNF.
It is a type error if, during the static analysis phase, an expression is found to have a static type that is not appropriate for the context in which the expression occurs, or during the dynamic evaluation phase, the dynamic type of a value does not match a required type as specified by the matching rules in 2.5.5 SequenceType Matching.
During the analysis phase, it is a static error if the static type assigned to an expression
other than the expression ()
or data(())
is empty-sequence()
.
It is a static error if an expression refers to an element name, attribute name, schema type name, namespace prefix, or variable name that is not defined in the static context, except for an ElementName in an ElementTest or an AttributeName in an AttributeTest.
An implementation that does not support the namespace axis must raise a static error if it encounters a reference to the namespace axis and XPath 1.0 compatibility mode is false.
It is a static error if the expanded QName and number of arguments in a static function call do not match the name and arity of a function signature in the static context.
It is a type error if the result of a path operator contains both nodes and non-nodes.
It is a type
error if E1
in a path expression
E1/E2
does not evaluate to a sequence of nodes.
It is a type error if, in an axis step, the context item is not a node.
It is a static error for an inline function expression to have more than one parameter with the same name.
An implementation MAY raise a static error if the value of a BracedURILiteral is of nonzero length and is neither an absolute URI nor a relative URI.
It is a dynamic error if the dynamic type of the
operand of a treat
expression does not match the
sequence type
specified by the treat
expression. This error might
also be raised by a path expression beginning with "/
"
or "//
" if the context node is not in a tree that is
rooted at a document node. This is because a leading
"/
" or "//
" in a path expression is an
abbreviation for an initial step that includes the clause
treat as document-node()
.
It is a static error if the expanded QName for an AtomicOrUnionType in a SequenceType is not defined in the in-scope schema types as a generalized atomic type.
The type must be the name of a type defined in the in-scope schema
types, and the {variety}
of the type must be
simple
.
A static
error is raised if one of the predefined prefixes
xml
or xmlns
appears in a namespace
declaration or a default namespace declaration, or if
any of the following conditions is statically detected in any
expression or declaration:
The prefix xml
is bound to some namespace URI other
than http://www.w3.org/XML/1998/namespace
.
A prefix other than xml
is bound to the namespace
URI http://www.w3.org/XML/1998/namespace
.
The prefix xmlns
is bound to any namespace URI.
A prefix other than xmlns
is bound to the namespace
URI http://www.w3.org/2000/xmlns/
.
It is a static
error if the target type of a cast
or
castable
expression is xs:NOTATION
xs:anySimpleType
, or
xs:anyAtomicType
.
It is a static error if a QName used in an expression contains a namespace prefix that cannot be expanded into a namespace URI by using the statically known namespaces.
In a cast expression, if an item is of type
xs:untypedAtomic
and the expected type is namespace-sensitive, a type error [err:XPTY0117] is
raised.
An implementation-defined limit has been exceeded.
It is a static
error [err:XPST0133] if the namespace URI for an EQName
is http://www.w3.org/2000/xmlns/
.
XQuery 3.0 does not support the namespace axis.
In the operator mapping tables, the term Gregorian refers
to the types xs:gYearMonth
, xs:gYear
,
xs:gMonthDay
, xs:gDay
, and
xs:gMonth
.
NaN specifies the string used for the NaN-symbol, which is used to represent the value NaN (not-a-number); the default value is the string "NaN"
SequenceType matching compares the dynamic type of a value with an expected sequence type.
Static Base URI. This is an absolute URI, used to resolve relative URI references.
Within this specification, the term URI refers to a Universal Resource Identifier as defined in [RFC3986] and extended in [RFC3987] with the new name IRI.
The term XDM instance is used, synonymously with the term value, to denote an unconstrained sequence of items in the data model.
An XPath 1.0 Processor processes a query according to the XPath 1.0 specification.
XPath 1.0 compatibility mode. This
value is true
if rules for backward compatibility with
XPath Version 1.0 are in effect; otherwise it is
false
.
An XPath 2.0 Processor processes a query according to the XPath 2.0 specification.
An XPath 3.0 Processor processes a query according to the XPath 3.0 specification.
An argument to a function call is either an argument expression or an ArgumentPlaceholder ("?").
Argument expressions are evaluated with respect to DC , producing argument values.
The number of Argument
s in an
ArgumentList
is its arity.
An atomic value is a value in the value space of an atomic type, as defined in [XML Schema 1.0] or [XML Schema 1.1].
Atomization of a sequence is defined as the result of
invoking the fn:data
function on the sequence, as
defined in [XQuery and XPath
Functions and Operators 3.0].
Available documents. This is a mapping of strings to
document nodes. Each string represents the absolute URI of a
resource. The document node is the root of a tree that represents
that resource using the data model. The document node is returned by
the fn:doc
function when applied to that URI.
Available node collections. This is a mapping of strings
to sequences of nodes. Each string represents the absolute URI of a
resource. The sequence of nodes represents the result of the
fn:collection
function when that URI is supplied as
the argument.
Available resource collections. This is a mapping of
strings to sequences of URIs. The string represents the absolute
URI of a resource which can be interpreted as an aggregation of a
number of individual resources each of which has its own URI. The
sequence of URIs represents the result of the
fn:uri-collection
function when that URI is supplied
as the argument.
Available text resources. This is a mapping of strings to
text resources. Each string represents the absolute URI of a
resource. The resource is returned by the
fn:unparsed-text
function when applied to that
URI.
An axis step returns a sequence of nodes that are reachable from the context node via a specified axis. Such a step has two parts: an axis, which defines the "direction of movement" for the step, and a node test, which selects nodes based on their kind, name, and/or type annotation.
The built-in functions supported by XPath 3.0 are defined in [XQuery and XPath Functions and Operators 3.0].
A collation is a specification of the manner in which strings and URIs are compared and, by extension, ordered. For a more complete definition of collation, see [XQuery and XPath Functions and Operators 3.0].
One way to construct a sequence is by using the comma operator, which evaluates each of its operands and concatenates the resulting sequences, in order, into a single result sequence.
The constructor function for a given type is used to
convert instances of other atomic types into the given type. The
semantics of the constructor function call T($arg)
are
defined to be equivalent to the expression (($arg) cast as
T?)
.
The context item is the item currently being processed.
Context item static type. This component defines the static type of the context item within the scope of a given expression.
When the context item is a node, it can also be referred to as the context node.
The context position is the position of the context item within the sequence of items currently being processed.
The context size is the number of items in the sequence of items currently being processed.
Current dateTime. This information represents an
implementation-dependent point
in time during the processing of an
expression, and includes an explicit timezone. It can be
retrieved by the fn:current-dateTime
function. If
invoked multiple times during the execution of an expression, this function always returns the same
result.
XPath 3.0 operates on the abstract, logical structure of an XML document, rather than its surface syntax. This logical structure, known as the data model, is defined in [XQuery and XPath Data Model (XDM) 3.0].
decimal-separator specifies the character used for the decimal-separator-symbol; the default value is the period character (.)
Default calendar. This is the calendar used when
formatting dates in human-readable output (for example, by the
functions fn:format-date
and
fn:format-dateTime
) if no other calendar is requested.
The value is a string.
Default collation. This identifies one of the collations
in statically known collations as the
collation to be used by functions and operators for comparing and
ordering values of type xs:string
and
xs:anyURI
(and types derived from them) when no
explicit collation is specified.
Default element/type namespace. This is a namespace URI or absentDM30. The namespace URI, if present, is used for any unprefixed QName appearing in a position where an element or type name is expected.
Default function namespace. This is a namespace URI or absentDM30. The namespace URI, if present, is used for any unprefixed QName appearing in a position where a function name is expected.
Default language. This is the natural language used when
creating human-readable output (for example, by the functions
fn:format-date
and fn:format-integer
) if
no other language is requested. The value is a language code as
defined by the type xs:language
.
Default node collection. This is the sequence of nodes
that would result from calling the fn:collection
function with no arguments.
Default place. This is a geographical location used to
identify the place where events happened (or will happen) when
formatting dates and times using functions such as
fn:format-date
and fn:format-dateTime
, if
no other place is specified. It is used when translating timezone
offsets to civil timezone names, and when using calendars where the
translation from ISO dates/times to a local representation is
dependent on geographical location. Possible representations of
this information are an ISO country code or an Olson timezone name,
but implementations are free to use other representations from
which the above information can be derived.
Default resource collection. This is the sequence of URIs
that would result from calling the fn:uri-collection
function with no arguments.
The delimiting terminal symbols are: "!", "!=", StringLiteral, "#", "$", "(", ")", "*", "+", (comma), "-", (dot), "..", "/", "//", (colon), "::", ":=", "<", "<<", "<=", "=", ">", ">=", ">>", "?", "@", BracedURILiteral, "[", "]", "{", "|", "||", "}"
digit-sign specifies the character used for the digit-sign in the picture string; the default value is the number sign character (#)
Informally, document order is the order in which nodes appear in the XML serialization of a document.
The dynamic context of an expression is defined as information that is available at the time the expression is evaluated.
A dynamic error is an error that must be detected during the dynamic evaluation phase and may be detected during the static analysis phase. Numeric overflow is an example of a dynamic error.
The dynamic evaluation phase is the phase during which the value of an expression is computed.
A dynamic function call consists of a base expression that returns the function and a parenthesized list of zero or more arguments (argument expressions or ArgumentPlaceholders).
A dynamic type is associated with each value as it is
computed. The dynamic type of a value may be more specific than the
static type of
the expression that computed it (for example, the static type of an
expression might be xs:integer*
, denoting a sequence
of zero or more integers, but at evaluation time its value may have
the dynamic type xs:integer
, denoting exactly one
integer.)
The effective boolean value of a value is defined as the
result of applying the fn:boolean
function to the
value, as defined in [XQuery and
XPath Functions and Operators 3.0].
A sequence containing zero items is called an empty sequence.
Environment variables. This is a mapping from names to values. Both the names and the values are strings. The names are compared using an implementation-defined collation, and are unique under this collation. The set of environment variables is implementation-defined and may be empty.
In addition to its identifying QName, a dynamic error may also carry a descriptive string and one or more additional values called error values.
An expanded QName consists of an optional namespace URI and a local name. An expanded QName also retains its original namespace prefix (if any), to facilitate casting the expanded QName into a string.
The expression context for a given expression consists of all the information that can affect the result of the expression.
An expression followed by a predicate (that is,
E1[E2]
) is referred to as a filter expression:
its effect is to return those items from the value of
E1
that satisfy the predicate in E2.
In a partial function application, a fixed position is an
argument/parameter position for which the ArgumentList
has an argument expression (as opposed to an
ArgumentPlaceholder
).
The first three components of the dynamic context (context item, context position, and context size) are called the focus of the expression.
Function coercion wraps a functionDM30 in a new function with signature the same as the expected type. This effectively delays the checking of the argument and return types until the function is invoked.
The function conversion rules are used to convert an argument value to its expected type; that is, to the declared type of the function parameter.
A generalized atomic type is a type which is either (a) an atomic type or (b) a pure union type
grouping-separator specifies the character used for the grouping-separator-symbol, which is typically used as a thousands separator; the default value is the comma character (,)
Ignorable whitespace consists of any whitespace characters that may occur between terminals, unless these characters occur in the context of a production marked with a ws:explicit annotation, in which case they can occur only where explicitly specified (see A.2.4.2 Explicit Whitespace Handling).
Implementation-dependent indicates an aspect that may differ between implementations, is not specified by this or any W3C specification, and is not required to be specified by the implementor for any particular implementation.
Implementation-defined indicates an aspect that may differ between implementations, but must be specified by the implementor for each particular implementation.
Implicit timezone. This is the timezone to be used when a
date, time, or dateTime value that does not have a timezone is used
in a comparison or arithmetic operation. The implicit timezone is
an implementation-defined value of
type xs:dayTimeDuration
. See [XML Schema 1.0] or [XML
Schema 1.1] for the range of valid values of a timezone.
In-scope attribute declarations. Each attribute declaration is identified either by an expanded QName (for a top-level attribute declaration) or by an implementation-dependent attribute identifier (for a local attribute declaration).
In-scope element declarations. Each element declaration is identified either by an expanded QName (for a top-level element declaration) or by an implementation-dependent element identifier (for a local element declaration).
The in-scope namespaces property of an element node is a set of namespace bindings, each of which associates a namespace prefix with a URI.
In-scope schema definitions. This is a generic term for all the element declarations, attribute declarations, and schema type definitions that are in scope during static analysis of an expression.
In-scope schema types. Each schema type definition is identified either by an expanded QName (for a named type) or by an implementation-dependent type identifier (for an anonymous type). The in-scope schema types include the predefined schema types described in 2.5.1 Predefined Schema Types.
In-scope variables. This is a mapping from expanded QName to type. It defines the set of variables that are available for reference within an expression. The expanded QName is the name of the variable, and the type is the static type of the variable.
infinity specifies the string used for the infinity-symbol; the default value is the string "Infinity"
The initial context item is a context item that an implementation can set before processing a query begins. The query body and the prolog of every module in a query share the same initial context item.
An inline function expression creates an anonymous functionDM30 defined directly in the inline function expression itself.
An item is either an atomic value, a node, or a functionDM30.
An alternative form of a node test called a kind test can select nodes based on their kind, name, and type annotation.
A lexical QName is a name that conforms to the syntax of [http://www.w3.org/TR/REC-xml-names/#NT-QName].
A literal is a direct syntactic representation of an atomic value.
minus-sign specifies the character used for the minus-sign-symbol; the default value is the hyphen-minus character (-, #x2D). The value must be a single character.
A node test that consists only of an EQName or a Wildcard is called a name test.
A named function is a function defined in the static context for the expression. To uniquely identify a particular named function, both its name as an expanded QName and its arity are required.
A named function reference denotes a named function.
Named functions. This is a mapping from (expanded QName, arity) to functionDM30.
The namespace-sensitive types are xs:QName
,
xs:NOTATION
, types derived by restriction from
xs:QName
or xs:NOTATION
, list types that
have a namespace-sensitive item type, and union types with a
namespace-sensitive type in their transitive membership.
A node is an instance of one of the node kinds defined in [XQuery and XPath Data Model (XDM) 3.0].
A node test is a condition on the name, kind (element, attribute, text, document, comment, or processing instruction), and/or type annotation of a node. A node test determines which nodes contained by an axis are selected by a step.
The non-delimiting terminal symbols are: IntegerLiteral, URIQualifiedName, NCName, DecimalLiteral, DoubleLiteral, QName, "ancestor", "ancestor-or-self", "and", "as", "attribute", "cast", "castable", "child", "comment", "descendant", "descendant-or-self", "div", "document-node", "element", "else", "empty-sequence", "eq", "every", "except", "following", "following-sibling", "for", "function", "ge", "gt", "idiv", "if", "in", "instance", "intersect", "is", "item", "le", "let", "lt", "mod", "namespace", "namespace-node", "ne", "node", "of", "or", "parent", "preceding", "preceding-sibling", "processing-instruction", "return", "satisfies", "schema-attribute", "schema-element", "self", "some", "text", "then", "to", "treat", "union"
When referring to a type, the term numeric denotes the
types xs:integer
, xs:decimal
,
xs:float
, and xs:double
.
A predicate whose predicate expression returns a numeric type is called a numeric predicate.
For each operator and valid combination of operand types, the operator mapping tables specify a result type and an operator function that implements the semantics of the operator for the given types.
A static or dynamic function call is a partial function application if one or more arguments is an ArgumentPlaceholder.
A path expression can be used to locate nodes within
trees. A path expression consists of a series of one or more
steps, separated by
"/
" or "//
", and optionally beginning
with "/
" or "//
".
pattern-separator specifies the character used for the pattern-separator-symbol, which separates positive and negative sub-pictures in a picture string; the default value is the semi-colon character (;)
per-mille specifies the character used for the per-mille-symbol; the default value is the Unicode per-mille character (#x2030)
percent specifies the character used for the percent-symbol; the default value is the percent character (%)
Primary expressions are the basic primitives of the language. They include literals, variable references, context item expressions, and function calls. A primary expression may also be created by enclosing any expression in parentheses, which is sometimes helpful in controlling the precedence of operators.
Every axis has a principal node kind. If an axis can contain elements, then the principal node kind is element; otherwise, it is the kind of nodes that the axis can contain.
A pure union type is an XML Schema union type that
satisfies the following constraints: (1) {variety}
is
union
, (2) the {facets}
property is
empty, (3) no type in the transitive membership of the union type
has {variety}
list
, and (4) no type in
the transitive membership of the union type is a type with
{variety}
union
having a non-empty
{facets}
property
To resolve a relative URI $rel
against a
base URI $base
is to expand it to an absolute URI, as
if by calling the function fn:resolve-uri($rel,
$base)
.
The node ordering that is the reverse of document order is called reverse document order.
A schema type is a type that is (or could be) defined using the facilities of [XML Schema 1.0] or [XML Schema 1.1] (including the built-in types of [XML Schema 1.0] or [XML Schema 1.1]).
A sequence is an ordered collection of zero or more items.
A sequence type is a type that can be expressed using the SequenceType syntax. Sequence types are used whenever it is necessary to refer to a type in an XPath 3.0 expression. The term sequence type suggests that this syntax is used to describe the type of an XPath 3.0 value, which is always a sequence.
A sequence containing exactly one item is called a singleton.
A singleton focus is a focus that refers to a single item; in a singleton focus, context item is set to the item, context position = 1 and context size = 1.
Document order is stable, which means that the relative order of two nodes will not change during the processing of a given expression, even if this order is implementation-dependent.
The static analysis phase depends on the expression itself and on the static context. The static analysis phase does not depend on input data (other than schemas).
The static context of an expression is the information that is available during static analysis of the expression, prior to its evaluation.
An error that can be detected during the static analysis phase, and is not a type error, is a static error.
A static function call consists of an EQName followed by a parenthesized list of zero or more arguments.
The static type of an expression is the best inference that the processor is able to make statically about the type of the result of the expression.
The Static Typing Feature is an optional feature of XPath that provides support for static semantics, and requires implementations to detect and report type errors during the static analysis phase.
Statically known decimal formats. This is a mapping
from QName to decimal format, with one default format that has no
visible name. Each format is used for serializing decimal
numbers using fn:format-number()
.
Statically known collections. This is a mapping from
strings to types. The string represents the absolute URI of a
resource that is potentially available using the
fn:collection
function. The type is the type of the
sequence of nodes that would result from calling the
fn:collection
function with this URI as its
argument.
Statically known documents. This is a mapping from
strings to types. The string represents the absolute URI of a
resource that is potentially available using the
fn:doc
function. The type is the static type of a call to
fn:doc
with the given URI as its literal argument.
Statically known collations. This is an implementation-defined mapping from URI to collation. It defines the names of the collations that are available for use in processing expressions.
Statically known default collection type. This is the
type of the sequence of nodes that would result from calling the
fn:collection
function with no arguments.
Statically known function signatures. This is a mapping from (expanded QName, arity) to function signatureDM30.
Statically known namespaces. This is a mapping from prefix to namespace URI that defines all the namespaces that are known during static processing of a given expression.
A step is a part of a path expression that generates a sequence of items and then filters the sequence by zero or more predicates. The value of the step consists of those items that satisfy the predicates, working from left to right. A step may be either an axis step or a postfix expression.
The string value of a node is a string and can be
extracted by applying the fn:string
function to the
node.
Substitution groups are defined in [XML Schema 1.0] and [XML Schema 1.1] Part 1. Informally, the substitution group headed by a given element (called the head element) consists of the set of elements that can be substituted for the head element without affecting the outcome of schema validation.
A sequence
type A
is a subtype of a sequence type
B
if the judgement subtype(A, B)
is
true.
The use of a value whose dynamic type is derived from an expected type is known as subtype substitution.
Each rule in the grammar defines one symbol, using the following format:
symbol ::= expression
Whitespace and Comments function as symbol separators. For the most part, they are not mentioned in the grammar, and may occur between any two terminal symbols mentioned in the grammar, except where that is forbidden by the /* ws: explicit */ annotation in the EBNF, or by the /* xgc: xml-version */ annotation.
A terminal is a symbol or string or pattern that can appear in the right-hand side of a rule, but never appears on the left-hand side in the main grammar, although it may appear on the left-hand side of a rule in the grammar for terminals.
Each element node and attribute node in an XDM instance has a type annotation ( described in [XQuery and XPath Data Model (XDM) 3.0]. ) The type annotation of a node is a reference to an XML Schema type.
A type error may be raised during the static analysis phase or the dynamic evaluation phase. During the static analysis phase, a type error occurs when the static type of an expression does not match the expected type of the context in which the expression occurs. During the dynamic evaluation phase, a type error occurs when the dynamic type of a value does not match the expected type of the context in which the value occurs.
Under certain circumstances, an atomic value can be promoted from one type to another. Type promotion is used in evaluating function calls (see <IP_ADDRESS> Evaluating Static and Dynamic Function Calls ) and operators that accept numeric or string operands (see B.2 Operator Mapping).
The typed value of a node is a sequence of atomic values
and can be extracted by applying the fn:data
function
to the node.
In the data model, a value is always a sequence.
A variable reference is an EQName preceded by a $-sign.
Variable values. This is a mapping from expanded QName to value. It contains the same expanded QNames as the in-scope variables in the static context for the expression. The expanded QName is the name of the variable and the value is the dynamic value of the variable, which includes its dynamic type.
In addition to static errors, dynamic errors, and type errors, an XPath 3.0 implementation may raise warnings, either during the static analysis phase or the dynamic evaluation phase. The circumstances in which warnings are raised, and the ways in which warnings are handled, are implementation-defined.
A whitespace character is any of the characters defined by [http://www.w3.org/TR/REC-xml/#NT-S].
xs:anyAtomicType
is an atomic type that includes
all atomic values (and no values that are not atomic). Its base
type is xs:anySimpleType
from which all simple types,
including atomic, list, and union types, are derived. All primitive
atomic types, such as xs:decimal
and
xs:string
, have xs:anyAtomicType
as their
base type.
xs:dayTimeDuration
is derived by restriction from
xs:duration
. The lexical representation of
xs:dayTimeDuration
is restricted to contain only day,
hour, minute, and second components.
xs:error
is a simple type with no value space,
defined in [XML Schema 1.1]. In
implementations that support XML Schema 1.1, it can be used in the
2.5.4 SequenceType
Syntax to raise errors.
xs:untyped
is used as the type annotation of
an element node that has not been validated, or has been validated
in skip
mode.
xs:untypedAtomic
is an atomic type that is used to
denote untyped atomic data, such as text that has not been assigned
a more specific type.
xs:yearMonthDuration
is derived by restriction from
xs:duration
. The lexical representation of
xs:yearMonthDuration
is restricted to contain only
year and month components.
zero-digit specifies the character used for the zero-digit-symbol; the default value is the digit zero (0). This character must be a digit (category Nd in the Unicode property database), and it must have the numeric value zero. This attribute implicitly defines the Unicode character that is used to represent each of the values 0 to 9 in the final result string: Unicode is organized so that each set of decimal digits forms a contiguous block of characters in numerical sequence.
This appendix provides a summary of the areas of incompatibility between XPath 3.0 and [XML Path Language (XPath) Version 1.0]. In each of these cases, an XPath 3.0 processor is compatible with an XPath 2.0 processor.
Three separate cases are considered:
Incompatibilities that exist when source documents have no schema, and when running with XPath 1.0 compatibility mode set to true. This specification has been designed to reduce the number of incompatibilities in this situation to an absolute minimum, but some differences remain and are listed individually.
Incompatibilities that arise when XPath 1.0 compatibility mode is set to false. In this case, the number of expressions where compatibility is lost is rather greater.
Incompatibilities that arise when the source document is processed using a schema (whether or not XPath 1.0 compatibility mode is set to true). Processing the document with a schema changes the way that the values of nodes are interpreted, and this can cause an XPath expression to return different results.
The list below contains all known areas, within the scope of
this specification, where an XPath 3.0 processor running with
compatibility mode set to true will produce different results from
an XPath 1.0 processor evaluating the same expression, assuming
that the expression was valid in XPath 1.0, and that the nodes in
the source document have no type annotations other than
xs:untyped
and xs:untypedAtomic
.
Incompatibilities in the behavior of individual functions are not listed here, but are included in an appendix of [XQuery and XPath Functions and Operators 3.0].
Since both XPath 1.0 and XPath 3.0 leave some aspects of the specification implementation-defined, there may be incompatibilities in the behavior of a particular implementation that are outside the scope of this specification. Equally, some aspects of the behavior of XPath are defined by the host language.
Consecutive comparison operators such as A < B <
C
were supported in XPath 1.0, but are not permitted by the
XPath 3.0 grammar. In most cases such comparisons in XPath 1.0 did
not have the intuitive meaning, so it is unlikely that they have
been widely used in practice. If such a construct is found, an
XPath 3.0 processor will report a syntax error, and the construct
can be rewritten as (A < B) < C
When converting strings to numbers (either explicitly when using
the number
function, or implicitly say on a function
call), certain strings that converted to the special value
NaN
under XPath 1.0 will convert to values other than
NaN
under XPath 3.0. These include any number written
with a leading +
sign, any number in exponential
floating point notation (for example 1.0e+9
), and the
strings INF
and -INF
.
Furthermore, the strings Infinity
and
-Infinity
, which were accepted by XPath 1.0 as
representations of the floating-point values positive and negative
infinity, are no longer recognized. They are converted to
NaN
when running under XPath 3.0 with compatibility
mode set to true, and cause a dynamic error when compatibility mode
is set to false.
XPath 3.0 does not allow a token starting with a letter to
follow immediately after a numeric literal, without intervening
whitespace. For example, 10div 3
was permitted in
XPath 1.0, but in XPath 3.0 must be written as 10 div
3
.
The namespace axis is deprecated as of XPath 2.0. Implementations may support the namespace axis for backward compatibility with XPath 1.0, but they are not required to do so. (XSLT 2.0 requires that if XPath backwards compatibility mode is supported, then the namespace axis must also be supported; but other host languages may define the conformance rules differently.)
In XPath 1.0, the expression -x|y
parsed as
-(x|y)
, and returned the negation of the numeric value
of the first node in the union of x
and
y
. In XPath 3.0, this expression parses as
(-x)|y
. When XPath 1.0 Compatibility Mode is true,
this will always cause a type error.
The rules for converting numbers to strings have changed. These
may affect the way numbers are displayed in the output of a
stylesheet. For numbers whose absolute value is in the range
1E-6
to 1E+6
, the result should be the
same, but outside this range, scientific format is used for
non-integral xs:float
and xs:double
values.
If one operand in a general comparison is a single atomic value
of type xs:boolean
, the other operand is converted to
xs:boolean
when XPath 1.0 compatibility mode is set to
true. In XPath 1.0, if neither operand of a comparison operation
using the <, <=, > or >= operator was a node set, both
operands were converted to numbers. The result of the expression
true() > number('0.5')
is therefore true in XPath
1.0, but is false in XPath 3.0 even when compatibility mode is set
to true.
In XPath 3.0, a type error is raised if the PITarget specified
in a SequenceType of form
processing-instruction(PITarget)
is not a valid
NCName. In XPath 1.0, this condition was not treated as an
error.
Even when the setting of the XPath 1.0 compatibility mode is false, many XPath expressions will still produce the same results under XPath 3.0 as under XPath 1.0. The exceptions are described in this section.
In all cases it is assumed that the expression in question was
valid under XPath 1.0, that XPath 1.0 compatibility mode is false,
and that all elements and attributes are annotated with the types
xs:untyped
and xs:untypedAtomic
respectively.
In the description below, the terms node-set and number are used with their XPath 1.0 meanings, that is, to describe expressions which according to the rules of XPath 1.0 would have generated a node-set or a number respectively.
When a node-set containing more than one node is supplied as an
argument to a function or operator that expects a single node or
value, the XPath 1.0 rule was that all nodes after the first were
discarded. Under XPath 3.0, a type error occurs if there is more
than one node. The XPath 1.0 behavior can always be restored by
using the predicate [1]
to explicitly select the first
node in the node-set.
In XPath 1.0, the <
and >
operators, when applied to two strings, attempted to convert both
the strings to numbers and then made a numeric comparison between
the results. In XPath 3.0, these operators perform a string
comparison using the default collating sequence. (If either value
is numeric, however, the results are compatible with XPath 1.0)
When an empty node-set is supplied as an argument to a function
or operator that expects a number, the value is no longer converted
implicitly to NaN. The XPath 1.0 behavior can always be restored by
using the number
function to perform an explicit
conversion.
More generally, the supplied arguments to a function or operator
are no longer implicitly converted to the required type, except in
the case where the supplied argument is of type
xs:untypedAtomic
(which will commonly be the case when
a node in a schemaless document is supplied as the argument). For
example, the function call substring-before(10 div 3,
".")
raises a type error under XPath 3.0, because the
arguments to the substring-before
function must be
strings rather than numbers. The XPath 1.0 behavior can be restored
by performing an explicit conversion to the required type using a
constructor function or cast.
The rules for comparing a node-set to a boolean have changed. In
XPath 1.0, an expression such as $node-set = true()
was evaluated by converting the node-set to a boolean and then
performing a boolean comparison: so this expression would return
true
if $node-set
was non-empty. In XPath
3.0, this expression is handled in the same way as other
comparisons between a sequence and a singleton: it is
true
if $node-set
contains at least one
node whose value, after atomization and conversion to a boolean
using the casting rules, is true
.
This means that if $node-set
is empty, the result
under XPath 3.0 will be false
regardless of the value
of the boolean operand, and regardless of which operator is used.
If $node-set
is non-empty, then in most cases the
comparison with a boolean is likely to fail, giving a dynamic
error. But if a node has the value "0", "1", "true", or "false",
evaluation of the expression may succeed.
Comparisons of a number to a boolean, a number to a string, or a
string to a boolean are not allowed in XPath 3.0: they result in a
type error. In XPath 1.0 such comparisons were allowed, and were
handled by converting one of the operands to the type of the other.
So for example in XPath 1.0 4 = true()
was true;
4 = "+4"
was false (because the string +4
converts to NaN
), and false = "false"
was
false (because the string "false"
converts to the
boolean true
). In XPath 3.0 all these comparisons are
type errors.
Additional numeric types have been introduced, with the effect
that arithmetic may now be done as an integer, decimal, or single-
or double-precision floating point calculation where previously it
was always performed as double-precision floating point. The result
of the div
operator when dividing two integers is now
a value of type decimal rather than double. The expression 10
div 0
raises an error rather than returning positive
infinity.
The rules for converting strings to numbers have changed. The
implicit conversion that occurs when passing an
xs:untypedAtomic
value as an argument to a function
that expects a number no longer converts unrecognized strings to
the value NaN
; instead, it reports a dynamic error.
This is in addition to the differences that apply when backwards
compatibility mode is set to true.
Many operations in XPath 3.0 produce an empty sequence as their
result when one of the arguments or operands is an empty sequence.
Where the operation expects a string, an empty sequence is usually
considered equivalent to a zero-length string, which is compatible
with the XPath 1.0 behavior. Where the operation expects a number,
however, the result is not the same. For example, if
@width
returns an empty sequence, then in XPath 1.0
the result of @width+1
was NaN
, while
with XPath 3.0 it is ()
. This has the effect that a
filter expression such as item[@width+1 != 2]
will
select items having no width
attribute under XPath
1.0, and will not select them under XPath 3.0.
The typed value of a comment node, processing instruction node,
or namespace node under XPath 3.0 is of type
xs:string
, not xs:untypedAtomic
. This
means that no implicit conversions are applied if the value is used
in a context where a number is expected. If a
processing-instruction node is used as an operand of an arithmetic
operator, for example, XPath 1.0 would attempt to convert the
string value of the node to a number (and deliver NaN
if unsuccessful), while XPath 3.0 will report a type error.
In XPath 1.0, it was defined that with an expression of the form
A and B
, B would not be evaluated if A was false.
Similarly in the case of A or B
, B would not be
evaluated if A was true. This is no longer guaranteed with XPath
3.0: the implementation is free to evaluate the two operands in
either order or in parallel. This change has been made to give more
scope for optimization in situations where XPath expressions are
evaluated against large data collections supported by indexes.
Implementations may choose to retain backwards compatibility in
this area, but they are not obliged to do so.
In XPath 1.0, the expression -x|y
parsed as
-(x|y)
, and returned the negation of the numeric value
of the first node in the union of x
and
y
. In XPath 3.0, this expression parses as
(-x)|y
. When XPath 1.0 Compatibility Mode is false,
this will cause a type error, except in the situation where
x
evaluates to an empty sequence. In that situation,
XPath 3.0 will return the value of y
, whereas XPath
1.0 returned the negation of the numeric value of
y
.
An XPath expression applied to a document that has been processed against a schema will not always give the same results as the same expression applied to the same document in the absence of a schema. Since schema processing had no effect on the result of an XPath 1.0 expression, this may give rise to further incompatibilities. This section gives a few examples of the differences that can arise.
Suppose that the context node is an element node derived from
the following markup: <background color="red green
blue"/>
. In XPath 1.0, the predicate
[@color="blue"]
would return false
. In
XPath 3.0, if the color
attribute is defined in a
schema to be of type xs:NMTOKENS
, the same predicate
will return true
.
Similarly, consider the expression @birth <
@death
applied to the element <person
birth="1901-06-06" death="1991-05-09"/>
. With XPath 1.0,
this expression would return false, because both attributes are
converted to numbers, which returns NaN
in each case.
With XPath 3.0, in the presence of a schema that annotates these
attributes as dates, the expression returns true
.
Once schema validation is applied, elements and attributes
cannot be used as operands and arguments of expressions that expect
a different data type. For example, it is no longer possible to
apply the substring
function to a date to extract the
year component, or to a number to extract the integer part.
Similarly, if an attribute is annotated as a boolean then it is not
possible to compare it with the strings "true"
or
"false"
. All such operations lead to type errors. The
remedy when such errors occur is to introduce an explicit
conversion, or to do the computation in a different way. For
example, substring-after(@temperature, "-")
might be
rewritten as abs(@temperature)
.
In the case of an XPath 3.0 implementation that provides the
static typing feature, many further type errors will be reported in
respect of expressions that worked under XPath 1.0. For example, an
expression such as round(../@price)
might lead to a
static type error because the processor cannot infer statically
that ../@price
is guaranteed to be numeric.
Schema validation will in many cases perform whitespace
normalization on the contents of elements (depending on their
type). This will change the result of operations such as the
string-length
function.
Schema validation augments the data model by adding default values for omitted attributes and empty elements.
This appendix lists the changes that have been made to this specification since the first publication of XPath 2.0 Recommendation.
The following names are now reserved, and cannot appear as function names (see A.3 Reserved Function Names):
function
namespace-node
switch
Code written for XQuery 1.0 processors may assume that every
item is either a node or an atomic value. This is no longer true,
since XQuery 3.0 introduces function items. Thus, an XQuery 1.0
function that declares a parameter as an item()
can
now have a function item passed as a parameter, which might not
have been anticipated by the author of the function.
No substantive changes were made during the Proposed Recommendation period.
Added FunctionBody to list of productions in description of Inline Functions. Resolves Bug 24199.
The following substantive changes have been made.
Removed
require-feature()
/prohibit-feature()
due
to implementation experience.
Added entry to J.1
Incompatibilities to indicate that function
,
namespace-node
, and switch
are all
reserved. Resolves Bug
20902.
Added entry to J.1 Incompatibilities to indicate that function items violate the XQuery 1.0/XPath 2.0 expectation that a every item is either a node or an atomic value. See https://lists.w3.org/Archives/Member/w3c-xsl-query/2013Feb/0050.htm (member only).
Fixed text for castable. Resolves Bug 21664.
Added error code [err:XPDY0130] for implementation-defined limits. Resolves Bug 21413.
Changed fn:map
to fn:for-each
, changed
fn:map-pairs
to fn:for-each-pair
. See
Bug
21128.
Adopted new definition of derives-from(AT, ET). Resolves Bug 20643.
If the NodeTest in an axis step is a NamespaceNodeTest then a static error is raised. Resolves Bug 20736.
A try/catch expression catches dynamic errors and type errors raised by the evaluation of the target expression of the try clause. Previously, the text referred to expressions lexically contained within the try clause. Resolves Bug 18877.
The host language must specify whether or not the XPath 3.0 processor normalizes all line breaks before parsing, and if it does so, whether it uses the rules of XML 1.0 or 1.1. Resolves Bug 14917.
Added support for xs:error
. Resolves Bug
20634.
If any component in the focus is defined, all components of the focus are defined. Resolves Bug 21011.
XPath expressions allow any legal XML Unicode character, subject only to constraints imposed by the host language. Bug 21574.
Changed XPTY0117 to FONS0004 in section 2.5.2, changed text of [err:XPTY0117]. Resolves Bug 21893.
Explicitly stated that no catch clause "matches" the error value, a the try/catch expression raises the error that was raised by the target expression. Resolves Bug 21666.
Changed "When tokenizing, the longest possible match that is valid in the current context is used." to "When tokenizing, the longest possible match consistent with the EBNF is used." Decided in Teleconference #541 2013-05-21.
Added an exception for subtype(Ai*, Bi?) when Ai is a pure union type with no member types, as in xs:error. Resolves Bug 20862.
Modified definition of statically known decimal formats in context. Resolves Bug 19365, see comment #10.
A processor must not raise errors for serialization parameters that it does not support. "A processor that is performing serialization must raise a serialization error if the values of any serialization parameters that it supports (other than any that are ignored under the previous paragraph) are incorrect."
Changed the second rule of <IP_ADDRESS> The judgement subtype-itemtype(Ai, Bi) and <IP_ADDRESS> The judgement subtype-itemtype(Ai, Bi) for the sake of transitivity. Resolves Bug 20632.
Removed the paragraph that said no published version of XML Schema references the XML 1.1 specifications, since this is no longer true.
Modified 2.5.6
SequenceType Subtype Relationships to better account for
xs:error
. Resolves Bug
22552.
Improved Step 5.b.ii.A in <IP_ADDRESS> Evaluating Static and Dynamic Function Calls .
The following are some of the editorial changes that have been made.
Deleted unused error, checked for consistency of errors. Resolves Bug 20837.
Added an example to show how to copy "unused" namespaces from
one node to another using in-scope-prefixes($e) ! namespace
{namespace-uri-for-prefix($e,.)} {.}
. Resolves Bug
21025.
Restored normative status of FunctionTest semantics - see <IP_ADDRESS> Function Test. They had been accidentally demoted to NOTE status. Resolves Bug 19341.
Added entry for || to A.4 Precedence Order (Non-Normative).
Deleted note on the converse relationship from 2.5.6 SequenceType Subtype Relationships.
Removed statement that implied the XQuery 3.0 requirements include a requirement for an XML-based representation.
The following substantive changes have been made.
Pure union types (formerly known as restricted union types) are now permitted in AtomicOrUnionTypes. Resolves Bug 13399.
Adopted the XML restriction that control characters #x1 to #x1F and 0x7F to 0x9F cannot appear in unescaped form in an XQuery. Resolves Bug 14921.
Function conversion rules depend on the setting of XPath 1.0 compatibility mode only for static functions. Resolves Bug 15398.
Added available text resources to the static context, as part of the resolution of Bug 14932.
Changed error XQST0046 for URI literals so that it is no longer dependent on the lexical space of xs:anyURI - the error is now raised if the value of a URILiteral or a BracedURILiteral is of nonzero length and is neither an absolute URI nor a relative URI. Resolves Bug 15675.
Clarified and extended rules for casting. Resolves Bug 15807.
Abandoned the special casting rule that prevented atomization for namespace sensitive types. Resolves Bug 16089.
The split of base URI into static base URI and dynamic base URI has been reverted. Resolves Bug 17595.
Changed the syntax of EQName to avoid conflicts with potential JSON syntax extensions in future versions. Resolves Bug 15399.
Relaxed rules that required inputs, outputs, and query modules to all use the same versions of XML, XML Names, and XML Schemas for names, characters, attribute value normalization, line-breaks, etc. Resolves Bug 15966.
Function items are now supported for context-dependent functions if they depend only on the static context. Resolves Bug 15912.
Removed error XPDY0229. Resolves Bug 16681.
Changed precedence of simple map operator, reorganized text accordingly. Resolves Bug 16197.
Integrated proposals on static and dynamic context from http://lists.w3.org/Archives/Member/w3c-xsl-query/2012May/0118.html. Resolves Bugs 14656, 14375, and 15791.
If there is a Comment before the end of a Version Declaration, an implementation must either raise an implementation-defined static error or ignore the commment. Decided in Montreal Face-to-Face, see https://lists.w3.org/Archives/Member/w3c-xsl-query/2012Jul/0081.html.
Changed rules for whitespace in URI Literals and Braced URI Literals in 2.4.5 URI Literals. Decided in face-to-face #517, 2012-07-23 to 2012-07-25.
Updated the appendix of implementation-defined items.
In E castable as T
, if E
raises a
dyanmic error, castable
returns false
, it
does not "fail". See 3.13.3
Castable.
Adopted rewording of <IP_ADDRESS> Schema Element Test. Resolves Bug 10207.
Corrected rule #17 of <IP_ADDRESS> The judgement subtype-itemtype(Ai, Bi) . Resolves Bug 19425.
Added error [err:XPST0133], which is raised if the namespace
URI for an EQName is http://www.w3.org/2000/xmlns/
, in
the early section on names. Removed duplicate material in the
section on node tests. Resolves Bug
19658.
Updated J.1
Incompatibilities to state that three function names are
now reserved (function
, namespace-node
,
and switch
). Fulfils Action A-523-06.
Ai is a subtype of Bi if Ai and Bi are both pure union types, and every type t in the transitive membership of Ai is also in the transitive membership of Bi. Resolves Bug 19504.
Added html-version
and item-separator
to Appendix C.1. Resolves Bug
20267.
Implementations must raise an error if limits are exceeded. Resolves Bug 20310.
The following are some of the editorial changes that have been made.
Introduced the concept of singleton focus, borrowed from XSLT, and used it to clarify context declaration. Resolves Bug 15789.
Reworked much of the prose re functions, to increase clarity and better accommodate dynamic function calls and partial function applications.
Reworked abstract and introductory text for XPath.
Consistently use "absent" for properties with no value in both static and dynamic context.
Removed erroneous references to modules in XPath.
Removed erroneous reference to XQST0034 codes in XPath.
More consistent use of terminology for raising an error, eliminating other terms (signal, report, raise, throw) that have been used in various versions of this specification over the years.
Eliminated Serialization section, which has no place in the XPath specification.
Improved the definition of static error.
Added a reference to XQuery try/catch expressions as a possible implementation-defined way to catch errors.
Editorial rewrite of the description of document order.
Corrected erroneous inclusion of XQuery text on function assertions in XPath.
Corrected several places where EQNames, QNames, and expanded QNames were conflated.
Simplified 3.1.2 Variable References so that it no longer enumerates expressions that bind variables, and merely refers to the static context. This simplifies maintenance of the specification.
Improved the definition of node test.
Removed change log entries that apply only to XQuery.
Removed a dangling note describing an obsolete error for context-sensitive functions in 3.1.6 Named Function References .
Fixed headings in Appendix C that implied that it describes static and dynamic contexts only for modules. Resolves Bug 20350.
The following substantive changes have been made in prior Working Drafts.
Applied all XPath 2.0 2ed errata.
Added named function references (3.1.6 Named Function References ).
Added inline function expressions (3.1.7 Inline Function Expressions).
Added dynamic function call (3.2.2 Dynamic Function Call ).
Added <IP_ADDRESS> Function Coercion.
Added 2.5.6 SequenceType Subtype Relationships, moving sequence type subtype judgments into the language specification rather than the formal semantics.
Clarified type information available to
derives-from()
in 2.5.5 SequenceType Matching.
Resolves Bug 6513,
Comment #21.
Modified derives-from()
in 2.5.5 SequenceType Matching
to support union types. Resolves Bug
7749.
Added let expressions.
Removed section on static typing extensions.
Added support for literal URLs in names, using EQNames.
Added support for XML Schema 1.1.
Added support for union types in function arguments.
Clarified wording on conflicts between function signatures and constructor functions in statically known function signatures.
Added missing consistency constraints for statically known
namespaces to 2.2.4
Consistency Constraints (the prefix xmlns
is
not bound to any namespace URI, no prefix is bound to the namespace
URI http://www.w3.org/2000/xmlns/
). Resolves Bug
10700.
Adopted rules for abstract elements in substitution groups: abstract elements do not appear in substitution groups, block attributes must be taken into account when building the substitution groups. Resolves Bug 10207.
Added missing semantics for EQNames with URILiterals. Resolves Bug 10857.
Added support for casting to union types. Resolves Bug 7860.
Allowed a URILiteral
in Wildcard
.
(This change appeared in an earlier draft, but was not mentioned in
the corresponding change log.)
How XDM instances are created from sources other than an Infoset or PSVI is implementation-defined. Resolves Bug 12208. (This change appeared in an earlier draft, but was not mentioned in the corresponding change log.)
Clarified use of Static Base URI, Dynamic Base URI per Bug 11561#c6. (This change appeared in an earlier draft, but was not mentioned in the corresponding change log.)
Adds errors for casts to namepace sensitive types in cast and function conversion rules. Resolves Bug 11964. (This change appeared in an earlier draft, but was not mentioned in the corresponding change log.)
Specified use of "unknown" types, including types from documents and types from other modules. Eliminated err:XQST0036. Resolves Bug 11095. (This change appeared in an earlier draft, but was not mentioned in the corresponding change log.)
Introduced Generalized atomic types, restricted unions in SequenceType to these types.
Added string concatenation operator "con" || "cat" ||
"enate"
Implemented simple mapping operator proposal using "!" operator. Resolves Bug 12951.
Changed rules for matching substitution groups. Resolves Bug 10065.
For a partial function application, a failure in the function conversion rules MUST raise a type error.
Function item coercion is required to raise a type error if there's a mismatch in the number of parameters (expected vs actual). Resolves Bug 14350.
In the triggers for err:XPST0112, broaden the class of functions that can't be referenced by partial function applications and named function references, from "focus-dependent" to "context-dependent built-in".
Added default language, calendar, and place to the dynamic context. Resolves Bug 14995.
Removed function annotations from XPath. Resolves Bug 14883.
Whether end-of-line handling is done before parsing is defined by the host language. Resolves Bug 14917.
Expanded definition of XPST0080 so that casting to xs:anySimpleType is also an error. Resolves Bug 19090.


SERVICE LEARNING INTERNSHIPS, 1-3 UNITS, (P/NP)
Internships through The Transfer Center are developed each semester and focus on addressing community needs, fostering leadership, and public service. Students can earn 1-3 units of academic credit while they take part in serving the needs of a dynamic student community.
In collaboration with staff, interns develop a specific service learning project area, with the goal of enhancing and/or expanding campus and community resources and enriching the university experience for transfer students.
A commitment of 45 hours per semester is required for each unit of academic credit available through the School of Social Welfare.
1 unit of credit = 45 semester hours
2 units of credit = 90 semester hours
3 units of credit = 135 semester hours
GRADING PROCEDURE:
In order to receive a passing grade students must:
-
Complete the required number of service hours based on unit enrollment,
-
Submit a monthly internship timesheet to their project supervisor for review,
-
Meet regularly with an assigned project supervisor for on-going information, training and/or to discuss project implementation.
-
Participate in required training/orientation activities
-
Document the final completion/outcomes of the service learning project.
STUDENT REQUIREMENTS:
Students will be required to:
-
Meet weekly with an assigned supervisor to discuss the accomplishment of specific learning objectives,
-
Become familiar with the centers programs, policies and procedures,
-
Develop an overview of community resources and campus services,
-
Explore needs and issues relevant to a culturally diverse student population.
To apply for an academic credit bearing internship send a resume and cover letter to Lorena Valdez at
<EMAIL_ADDRESS>Here are links to the
SUMMER INTERNSHIP APPLICATION
and the
ACADEMIC YEAR INTERNSHIP APPLICATION
PEER ADVOCATES
-
This team of transfer students staff the information and referral desk during regular hours of operation, Monday-Friday,9 am-5 pm. They serve as key resources on navigating the academic, social and cultural terrain f the university. They provide additional assistance by helping to keep the center a welcoming and inviting space for all transfer students on campus.
Here is a short interview with Steven Nguyen, The Transfer Student Center's Academic Achievement Counselor, answering some questions on the roles of Peer Advocates and Interns in the Transfer Student Center:
Q: What are some qualities you look for when hiring a Peer Advocate/selecting an intern?
A: I usually seek out individual who show Initiative, Customer Service Skills, Public Speaking skills, and have interest in helping others.
Q: What is the difference between and intern and a Peer Advocate?
A: Interns and Peer Advocate do not differ too much. Interns get units, Peer Advocate get compensated.
Q: How do you train your students?
A: We have a Formal Training Schedule.
Q: How do you create a weekly schedule?
A: We use a Doodle to see everyones availability. I then create a calendar for the week, send it out to all Peer Advocates/Interns and post it at the front desk.
Q: What is expected of a Peer Advocate?
A: They must work 10 hours, represent the transfer center, and participate in project areas.
Q: How do you feel the Peer Advocates and Interns benefit the center?
A: This is outlined in the
Transfer Student Center Peer Advocate Manual
. They are the life and heart beat of the center. They truly are the center
Q: What is your job, as a leader, for these student employees?
A: To help inform them to the best of my knowledge and create a environment they enjoying working for.
The Lead Peer Advocate
1. What are some qualities you think are important for a Lead Peer Advocate to have?
-
A Lead Peer Advocate should have experience, initiative, drive/passion, and presence. A lead peer advocate should be a peer advocate before transitioning into the lead role in order to gain the knowledge of the transfer resources, the transfer culture, and the job itself. While working as a peer advocate, the lead should show initiative in "bettering" the transfer student center, such as finding ways to improve transfer resources, provide better service for the students that enter the center, improving the transfer student space, etc. This initiative will also reflect on his/her passion and drive for the work done at the center. Like any good leader, the lead peer advocate should have good social/communication skills that will allow for him/her to be successful in guiding other peer advocates as well as the transfer students on campus. Lastly, his/her presence will allow for others to also be passionate for the mission of the transfer student center.
2. What sets you apart from Peer Advocates?
-
The Lead Peer Advocate typically has shown a strong sense of leadership within the role. The lead shows a strong work ethic and organizational skills that allow for exemplary leadership on and off the job. The lead's initiative to improve the center allows for him/her to stand out from the rest of the peer advocates.
3. What are your most important responsibilities and how do you handle them?
-
The Lead Peer Advocate organizes and produces the weekly front desk schedule, while communicating with the peer advocates to fill in any and all empty shifts. The Lead Peer Advocate takes a leadership role in several events that require a Transfer representative. The lead also helps plan and facilitate the training sessions for the peer advocates and any other meetings with the transfer staff. The lead should be able to assist the peer advocates with any questions, concerns, or activities, as well as oversee the needs at the front desk.
4. Is there anything in particular that you would like to share with a future Lead?
-
"Have patience with the different roles that you have to play while being a Lead. The job requires for you to get creative sometimes so don't be afraid of trying new methods to achieve your duties as a Lead. Never feel like you can't be unsure about something. Ask many questions! Keep learning and challenging yourself. Enjoy what you do and always let your passion flow with the work that you do at the center."


Is sitting really the new smoking? No.
“Sitting is more dangerous than smoking,
kills more people than HIV, and is more treacherous than parachuting.
We are sitting ourselves to death.”
- Dr. James Levine, Mayo Clinic
Employees are paying for it with their health
Drastically shortened life span. Joint pain and muscle discomfort. Greatly increased risk of chronic disease. Poor mental and emotional health.1
Employers are paying for it with their pocketbook
The average employer loses $4,500 per employee per year because of employee inactivity.2,3,5
Decreased productivity
Due to health risk factors, the average employee performs at only 70% of full capacity, which costs employers half a trillion dollars annually.4,5 For every dollar spent on healthcare, a company loses between $2 and $20 in productivity.3
Higher healthcare costs
The top 10 causes of rising workplace healthcare costs--cancer, back/neck pain, heart disease, chronic pain, high cholesterol, depression, obesity, arthritis, and anxiety--have one common cause: long periods of sitting.3
ROI
Healthy employees = Healthy bottom line
Adverse health effects from prolonged inactivity cannot be negated by exercise or diet,
meaning expensive activity trackers, group gym memberships, employee fitness classes, and nutrition coaching from
traditional wellness programs are a waste of your resources.6
Why is
right for you?
SIMPLE & AFFORDABLE: Our program doesn't feel like a program. It's the least obtrusive and most affordable in the industry. No online portal for "Slim in 6 Seconds" challenges integrated with mobile apps. Just 30-minute activity sessions that fit seamlessly into your routine, at a price every employer and employee can afford (seriously).
SCIENTIFIC: Using the most up-to-date and sound research, our work addresses the root cause of problems in the musculoskeletal, cardiorespiratory, endocrine, and nervous systems.
One example: Most wellness programs recommend stretching for tight muscles, but stretching actually tightens a muscle even more.
EFFECTIVE: Increased employee productivity. Lower absenteeism and presenteeism. Reduced healthcare expenses.
(504) 418-6356


--- layout: default title: Overflight description: Overflight, various dimensions, acryl on canvas, 2010. permalink: /painting/overflight/ group: painting-project parent: painting lang: en language: English thumbnail: eva-mikulasova-overflight-04-2010-acryl-on-canvas-various-dimensions-tile order: 3 ---
Overflight, 2010, acryl on canvas, various dimensions.
Overflight, 2010, acryl on canvas, various dimensions.
Overflight, 2010, acryl on canvas, various dimensions.
Overflight, 2010, acryl on canvas, various dimensions.
Painting instalation Overflight (approx. 550x550cm) is compounded of over 60 different sized formats.
It is based on my personal experience of a bird flock. It represents something enormous, untouchable, something that is beyond man. It is reduced to almost black and white and it is characteristic by minimal brush strokes that created a huge structure.
For me, it was an expresion of power of little things.


{% load staticfiles %}
<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>By continuing, you agree to our Terms & Conditions
Chris Wanstrath
Former CEO @ Github
<EMAIL_ADDRESS>Santiago Zavala
Partner @ 500 Startups
<EMAIL_ADDRESS>Chris Wanstrath
Former CEO @ Github
<EMAIL_ADDRESS>Jonathan Chavez
Developer @ Cardd
<EMAIL_ADDRESS>Satya Nadella
CEO @ Microsoft
<EMAIL_ADDRESS>Sebastian Crossa
Designer @ Cardd
<EMAIL_ADDRESS>Cardd
Sam Altman
President @ YCombinator
<EMAIL_ADDRESS>By continuing, you agree to our Terms & Conditions


--- author: Joe B categories: app date: '2009-11-26 12:41:58' link: http://blogs.nitobi.com/joe/2009/11/26/android-1-5-to-2-0-support-in-edge/ permalink: /2009/11/26/android-1-5-to-2-0-support-in-edge/ slug: android-1-5-to-2-0-support-in-edge status: publish title: Android 1.5 to 2.0 Support in EDGE type: post format: html ---
After spending a day with Java reflection, I believe that we are now at the point where PhoneGap Android can now be supported on 1.5, 1.6 and 2.0 versions of Android. This wasn't incredibly hard, except for the fact that I was unfamiliar with reflection, and the example on the Android site is less than helpful, since it deals with the Debug static methods, and not a real world object that can have things like instances. Also, reading Sun's documentation made me realize how useless examples that use the word Class is as a classname.
The result of this is that we may have a JAR that can be used on Android 1.5, 1.6 and 2.0, which solves the divergence issue. However, this doesn't mean that we have SQLite database storage that doesn't exist on Android 1.5 or 1.6. It means that if you are using Android 2.0, you have access to the SQLite Database if you are running the Edge version.
After pairing down PhoneGap to a jar, it appears to be weighing in at under 200k. I'm thinking about distributing it as an installable library on Android so that if you have it installed, you can download PhoneGap compatible APKs. This would be similar to the Text-To-Speech API functionality. This may encourage Google to close the browser gap, or it may just get ignored if people just use their own stand-alone PhoneGap + app apps.
More info on this will come shortly.


Google Is Going to Start Offering Bank Accounts
by Victor TangermannGoogle Checking
Some of the biggest tech companies in the world, including Apple, have been trying to break into the personal banking space by offering credit cards and checking accounts to their customers.
Now, according to an exclusive report by The Wall Street Journal, Google is joining those efforts — with a plan to start offering checking accounts to its billions of users.
Tech Bank
Google competitor Facebook has struggled to break into the financial space. Its plans to establish Libra, an international cryptocurrency, have been met with criticism from governments around the world. A large number of partners and investors have already backed out prior to a planned 2020 launch.
Google’s plans are not quite as ambitious as Libra. The idea is to have users access their checking accounts through Google’s digital wallet, Google Pay, according to WSJ — the same app that allows customers to pay for stuff using their Android smartphones. So far, the service has almost 100 million users.
But there’s one massive hurdle Google will have to inevitably cross to make its banking services a real choice to consumers: it will have to convince them their personal data is safe.
READ MORE: Next in Google’s Quest for Consumer Dominance—Banking [The Wall Street Journal]
More on Silicon Valley and finance: Facebook’s Cryptocurrency is Collapsing in Front of Our Eyes


Compute adjusted p values using one or more adjustment types for multiple tests.
STATS PADJUST
DSNAMES=variable DSPVALUES=variable
or
NAMELIST = quoted list of names PLIST = list of p values
METHOD=FDR HOLM HOCHBERG HOMMEL BY BONFERRONI
NTESTS=number
/OUTPUT PLOT=YES** or NO.
/HELP
* Required
** Default
STATS GET R /HELP. prints this information and does nothing else.
STATS PADJUST NAMELIST="x" "y" "z" PLIST=.001 .005 .05.
The input for this command is either from the active dataset or specified on the command line. For dataset input, specify the name of a variable holding a label for each p value as DSNAMES and the name of the variable holding the p values as DSPVALUES.
For input on the command line, specify the pvalues to PLIST and, optionally, specify a list of names to NAMELIST. The names should be quoted.
Specify the methods to be used as METHOD. The choices are
FDR and BY are used to control the false discovery rate, which is the expected proportion of false positives among the hypotheses that are rejected. The other methods are used to control the familywise error rate and are more conservative. The distinction becomes more important as the number of tests grows. Hochberg and Hommel assume that the tests are independent or are not negatively correlated.
By default, the number of tests is assumed to be the same as the number of p values supplied. However, you can use NTESTS to set a larger number. This assumes that the omitted p values are either larger than any of the included ones (Bonferroni and Holm) or are equal to 1.
PLOT specifies whether or not to produce a plot of the adjusted p values against the unadjusted ones.
© Copyright IBM Corp. 1989, 2014


Congratulations!....
Enter your details below to see your results and also see your free gift
First Name
*
Email Address
*
We respect your privacy.
Enter your details above to claim it.


Ohun is the Yoruba word for voice and is a simple audio conferencing solution for Openfire using the Kraken WebRTC server and client. It is for remote teams who will use it everyday to communicate and collaborate all day long without the need to show their faces or any other video. With the absence of video, it will ensure high quality audio for the conversation at most times, even with more than 10 participants.
You will need a turn server if your Openfire is running inside a container like Docker or behind a NAT. Use the PionTurn plugin for Openfire or Coturn (linux only). If you use a turn server than also use the external service discovery plugin for openfire in order for the web client to discover it.


Together we electrify China in the new era
Energy Management Conference China 2018
Photo sharing
Upload failed!
{include file="common/jssdk" /} {include file="common/share" /} {include file="common/google" /}


--- layout: page title: About permalink: /about/ main_image_path: /uploads/img-20201015-133135.jpg main_image_caption: frontpage: false homepage_description_markdown: frontpagetitle: About order_number: 1 thumb_crop: true images: - image_path: image_title: image_description: _options: layout: hidden: true main_image_path: width: 1200 height: 1200 resize_style: contain mime_type: image/jpeg image_path: width: 1200 height: 1200 resize_style: contain mime_type: image/jpeg _comments: title: Page title permalink: Be careful editing this main_image_path: Image used to represent your page frontpage: Show this page on the homepage homepage_description_markdown: Text used on homepage if shown frontpagetitle: Alternative title for home page use images: Add and edit images here ---


Classes
Fleximage
Fleximage::ImageProxy
Fleximage::Model
Fleximage::Model::ClassMethods
Fleximage::Model::InstanceMethods
Fleximage::Operator
Fleximage::Operator::Base
Fleximage::Operator::Border
Fleximage::Operator::Crop
Fleximage::Operator::ImageOverlay
Fleximage::Operator::Resize
Fleximage::Operator::Shadow
Fleximage::Operator::Text
Fleximage::Operator::Trim
Fleximage::Operator::UnsharpMask


|
Doxygen Demo
v1.0
Working Demonstration of Doxygen
|
#include <Car.h>
Public Member Functions | |
| Car (string make, string model, int year, int cost) | |
| string | getMake () |
| string | getModel () |
| int | getYear () |
| int | getCost () |
| bool | highClass () |
represents a car with an make, model, year, and cost
| Car::Car | ( | string | make, |
| string | model, | ||
| int | year, | ||
| int | cost | ||
| ) |
| int Car::getCost | ( | ) |
| string Car::getMake | ( | ) |
| string Car::getModel | ( | ) |
| int Car::getYear | ( | ) |
| bool Car::highClass | ( | ) |


The differences between HTML and CSS
HTML and CSS work hand in hand. HTML is the skeleton of a website, while CSS dresses up the site by making it visually
appealing.
A closet, like HTML, is a skeleton. The closet contains clothes, shoes and miscellaneous items. HTML contains content
(images, text, links) which forms the skeleton of a website.
All websites are unique. This is where CSS comes into place. You can use the CSS properties to define the font size,
style, colour, image size, it's placement, background colour, and many more things. A closet can be 'dressed' up by
introducing various colours, designs, and types of clothing, shoes and bags.
In your closet, you can turn on the switch, open drawers, lock or unlock your drawers. In your website, JavaScript is
responsible for making your site interactive. It does that through functions which can be built-in, or you can create it
from scratch.
Description of control flow and loops using an example process from everyday life.
Control flow, also known as a condition flow is the order in which the computer executes the statement in the script.
Control flow statements decide the order in which the statement will be executed. For example, when going for a run I
check the weather by looking out the window, if it's raining, I will wear my water and windproof jacket, track pants and
a beanie. Or else the weather is good then I will wear my normal running gear.
Looping is used when you need to perform the same action(s) many times or x numbers of times in a row. In Hindu
culture, a couple is not considered married until they circle the fire seven times. This means that for a couple to
marry, they need to continue to circle the fire seven times.
Describe what the DOM is and an example of how you might interact with it.
The Document Object Model (DOM) is an application programming interface (API) for HTML and XML which defines the
logical structure of the document.
DOM helps interact with the document; you can navigate, add, modify or delete the element or content of the HTML or
XML document; it can be done using a scripting language such as JavaScript.
The difference between accessing data from arrays and objects.
When you want to retrieve information from the array, you use the index of each element. An array is a zero-based index so, counting starts at 0. If you want to retrieve the first element of an array, you will use index 0. for example:
var fruit = ["Apple", "Banana", "Orange", "Kiwi"];
console.log(fruit [0]);
// The result will be "Apple".
You can access object properties in two ways, using "." or "[]" notations. Let's create the car object first.
var car = {
color: 'red',
year: '2020',
make: 'Suzuki'
}
We will access the data using "." notation.
car.color // returns red
car.year //returns 2020
Now we will access the data using "[]" notation. so, for that we will first create the car object.
var car = {
"color": "red'",
"year": "2020",
"make": "Suzuki"
}
To acess the data:
car ["make"] // returns Suzuki
Explain what functions are and why they are useful.
A function is a block of code, that is designed to perform any particular task. In JavaScript function is defined using
"function" keyword. You can execute the function by calling it, and it is known as calling or invoking a function.
Functions shorten your codes and save your time from writing the same piece of code again and again. It may not feel
like a great deal at first, but it is beneficial, especially when you have to write the 2k-3k lines of code. JavaScript
has many built-in functions, and it also allows us to create our functions.


Bug#1 - Length of geneic sequence needs to be in multiple of 3.
Bug#2 - Stuck with results when no stop codon is found.
Developed by Soumya Acharya.


--- layout: default title: Home ---
Maracas is a source code and bytecode analysis framework—written in Rascal and Java—that is designed to support the co-evolution of Java Application Programming Interfaces (APIs) and client code. Maracas relies on japicmp to compute the list of breaking changes between two API versions. Afterwards, it is able to identify declarations within a client project that are impacted by the aforementioned breaking changes (a.k.a. detections).


Tic-Tac-Toe is a game played on a 3x3 board. The players alternate claiming spots on the board until one player has 3 spots in a row (horizontally, vertically, or diagonally), or there are no spots left to claim. The first player to move will always use 'O's to claim his spots whereas the second player will use 'X's. Claiming 3 spots in a row means you win and play stops. If no spots are left and nobody has won, the game is a draw.
By examing a Tic-Tac-Toe board it is often possible to determine whether a particular player should win. More precisely, a player should win if there exists a sequence of moves such that, regardless of his opponent's moves, he will always win. Another way of saying this is, a player should win a given position if playing the right moves will always produce a win regardless of the opposition's efforts to thwart his victory.
You will be a given a String[]board describing the current state of the game. board will contain 3 elements representing the rows of the board. Each element will contain 3 characters representing the spots in that row. For example:
board = {"XO."
"..."
".OX"}
As seen above, the 'X's and 'O's represent each player's respective moves and the '.'s represent unclaimed spots. Your method will return a String according to the following rules:
1) If the board position is invalid (could not be achieved through a succession of valid moves) return "INVALID"
2) If the first player (player using 'O's) should win or has already won return "FIRST"
3) If the second player (player using 'X's) should win or has already won return "SECOND"
4) Otherwise return "DRAW"
In the example above the board position is valid and the first player should win so you would return "FIRST". Note, rule 1 has precedence over the other rules.
Definition
ClassTicSolver
MethodwhoWins
Parameters
tuple(string)
Returns
string
Method signature
def whoWins(self, board)
(be sure your method is public)
Limits
Time limit (s)2.000
Memory limit (MB)64
Constraints
board will contain exactly 3 elements
Each element of board will contain exactly 3 characters
Each character in board will be one of 'X', 'O', or '.' (quotes for clarity)
Test cases
input
board
{"OX.", "...", "..."}
output
Returns
"FIRST"
note
If the first player plays the center spot, the second player is forced to block him in the lower right spot:
OX.
.O.
..X
The first player can then play the lower left spot thus giving him two ways to get three in a row. Since this line of play is unstoppable by the second player, the first player should win.
input
board
{"O..", ".X.", "..."}
output
Returns
"DRAW"
note
Nobody has a line of play that will assure victory.
input
board
{"OXO", "OOX", "X.X"}
output
Returns
"DRAW"
note
The first player has only one choice leading to a draw.
input
board
{"OOO", "XX.", "..."}
output
Returns
"FIRST"
input
board
{"...", "...", "..."}
output
Returns
"DRAW"
input
board
{"O..", "XX.", "..."}
output
Returns
"INVALID"
note
The second player has gone twice, but the first player has only gone once.
input
board
{"XXX", "OO.", "OO."}
output
Returns
"INVALID"
note
Looking at the number of spots occupied it is clear that the first player has just moved. It is impossible then, that the second player has already won.
input
board
{"OXO", "X.X", "OXO"}
output
Returns
"FIRST"
This problem statement is the exclusive and proprietary property of TopCoder, Inc. Any unauthorized use or reproduction of this information without the prior written consent of TopCoder, Inc. is strictly prohibited. (c)2003, TopCoder, Inc. All rights reserved.


Illustration
Here are some illustrations I've made over the past couple years. Most of them are hand-drawn using ink or paint pens, then colored and finished digitally. A few are 100% digital.
Here are some illustrations I've made over the past couple years. Most of them are hand-drawn using ink or paint pens, then colored and finished digitally. A few are 100% digital.


Welcome to FlashCard’s documentation!¶
- api.create_app()¶
Create Flask application.
import dependancies
- auth.login()¶
this method is used by registered users to sign in to their account
- auth.signup()¶
this method is used to create new users and register them in firebase
routes.py is a file in cards folder that has all the functions defined that manipulate the cards. All CRUD functions that needs to be performed on cards are defined here.
- cards.createcards(deckId)¶
This method is routed when the user requests to create new cards in a deck. Only the deckid is required to add cards to a deck.
- cards.deletecard(id, cardid)¶
This method is called when the user requests to delete the card. The deckid and the particular cardid is required to delete the card.
- cards.getcards(deckId)¶
This method is called when the user want to fetch all of the cards in a deck. Only the deckid is required to fetch all cards from the required deck.
- cards.updatecard(id, cardid)¶
This method is called when the user requests to update cards in a deck. The card can be updated in terms of its word and meaning. Here deckid and cardid is required to uniquely identify a updating card.
routes.py is a file in deck folder that has all the functions defined that manipulate the deck. All CRUD functions are defined here.
- deck.create()¶
This method is routed when the user requests to create a new deck. To create a new deck, userID, title, description and vissibility are the input required.
- deck.delete(id)¶
This method is called when the user requests to delete the deck. Only the deckid is required to delete the deck.
- deck.getdeck(id)¶
This method is called when we want to fetch one of the decks, we pass deckid of this deck
- deck.getdecks()¶
This method is called when we want to fetch all of the decks. Here, we check if the user is authenticated, if yes show all the decks made by the user including the ones with private vissibility. if the user is not authenticated then only show decks that have public vissibility.
- deck.update(id)¶
This method is called when the user requests to update the deck. The deck can be updated in terms of its title, description and vissibility.


New account
Not yet registered?
This section demonstrates account registration which is a common activity online. These days sites often use authentication backends such as Googles Oauth
{% extends 'Home/home-template.html' %} {% block title %} Create Profile {% endblock %} {% block auth_action %} Login {% endblock %} {% block navbar %} {% endblock %} {% block body %}
Not yet registered?
This section demonstrates account registration which is a common activity online. These days sites often use authentication backends such as Googles Oauth


JavaScript is disabled on your browser.
Skip navigation links
Overview
Package
Class
Use
Tree
Deprecated
Index
Help
Prev Letter
Next Letter
Frames
No Frames
All Classes
A
C
D
E
F
G
H
I
J
L
M
N
O
P
R
S
T
U
V
W
X
Y
A
about()
- Method in class controller.
HomeController
AbstractHomeController
- Class in
controller
AbstractHomeController(HomeModel, UserPreferences)
- Constructor for class controller.
AbstractHomeController
actionPerformed(ActionEvent)
- Method in class io.
ControllerAction
actionPerformed(ActionEvent)
- Method in class io.
ResourceAction
ActionType()
- Constructor for enum swing.
HomePane.ActionType
ActionType()
- Constructor for enum swing.
PlanComponent.ActionType
add(Category)
- Method in class metier.
Catalog
methode utilitaire : ajoute une categorie à ce catalogue si 1 categorie
de m nom que celle en parametre existe déjà ds cette categorie une exception
add(Category, CatalogPieceOfFurniture)
- Method in class metier.
Catalog
methode utilitaire : ajoute un meuble pour les sous classes
add(CatalogPieceOfFurniture)
- Method in class metier.
Category
addCatalogSelectionListener()
- Method in class controller.
HomeController
addFocusListener(PlanController)
- Method in class swing.
PlanComponent
addFurniture(List<HomePieceOfFurniture>)
- Method in class controller.
FurnitureController
addFurnitureListener(FurnitureListener)
- Method in class metier.
Home
addFurnitureListener(FurnitureListener)
- Method in interface metier.
HomeModel
addHome(HomeModel)
- Method in class swing.
HomeApplication
addHomeFurniture()
- Method in class controller.
AbstractHomeController
addHomeFurniture()
- Method in class controller.
FurnitureController
addHomeFurniture()
- Method in class controller.
HomeController
addHomeFurniture()
- Method in interface controller.
HomeFurnitureController
addHomeListener(HomeModel)
- Method in class swing.
FurnitureTable.FurnitureTableModel
addHomeListener(HomeListener)
- Method in class swing.
HomeApplication
addHomeListeners(HomeModel, Group)
- Method in class swing.
HomeComponent3D
addHomeSelectionListener()
- Method in class controller.
HomeController
addListeners()
- Method in class controller.
HomeController
addListeners(HomeModel, HomeApplication, HomeFrameController, JFrame)
- Method in class swing.
HomeFramePane
addModelListeners(HomeModel)
- Method in class swing.
PlanComponent
addMouseListeners(PlanController)
- Method in class swing.
PlanComponent
addPieceOfFurniture(HomePieceOfFurniture)
- Method in class metier.
Home
addPieceOfFurniture(HomePieceOfFurniture, int)
- Method in class metier.
Home
addPieceOfFurniture(HomePieceOfFurniture)
- Method in interface metier.
HomeModel
addPieceOfFurniture(HomePieceOfFurniture, int)
- Method in interface metier.
HomeModel
addPieceOfFurniture(Group, HomePieceOfFurniture)
- Method in class swing.
HomeComponent3D
addPropertyChangeListener(String, PropertyChangeListener)
- Method in class metier.
Home
addPropertyChangeListener(String, PropertyChangeListener)
- Method in interface metier.
HomeModel
addPropertyChangeListener(String, PropertyChangeListener)
- Method in class metier.
UserPreferences
addSelectionListener(SelectionListener)
- Method in class metier.
Catalog
addSelectionListener(SelectionListener)
- Method in class metier.
Home
addSelectionListener(SelectionListener)
- Method in interface metier.
HomeModel
addSelectionListeners(Catalog, CatalogController)
- Method in class swing.
CatalogTree
addSelectionListeners(HomeModel, FurnitureController)
- Method in class swing.
FurnitureTable
addTreeModelListener(TreeModelListener)
- Method in class swing.
CatalogTree.CatalogTreeModel
listener add
addUndoSupportListener()
- Method in class controller.
HomeController
addUserPreferencesListener(UserPreferences)
- Method in class swing.
FurnitureTable
addWall(Wall)
- Method in class metier.
Home
addWall(Wall)
- Method in interface metier.
HomeModel
addWall(Group, Wall, HomeModel)
- Method in class swing.
HomeComponent3D
addWallListener(WallListener)
- Method in class metier.
Home
addWallListener(WallListener)
- Method in interface metier.
HomeModel
AddWordToListEdit(List<String>, String)
- Constructor for class junit.
UndoManagerTest.AddWordToListEdit
application
- Variable in class controller.
HomeController
application
- Variable in class controller.
HomeFrameController
application
- Static variable in class main.
SweetHome3DJavaWebStart
application
- Variable in class swing.
HomeFramePane
assertActionsEnabled(boolean, boolean, boolean, boolean)
- Method in class junit.
HomeControllerTest
assertActionsEnabled(HomeController, boolean, boolean, boolean, boolean)
- Method in class junit.
TransferHandlerTest
assertContentEquals(String, Content, Content)
- Method in class junit.
HomeFileRecorderTest
assertCoordinatesEqualWallPoints(float, float, float, float, Wall)
- Method in class junit.
PlanComponentTest
assertEquals(Wall, Wall)
- Method in class junit.
HomeFileRecorderTest
assertEquals(HomePieceOfFurniture, HomePieceOfFurniture)
- Method in class junit.
HomeFileRecorderTest
assertHomeContains(HomeModel, Wall...)
- Method in class junit.
PlanComponentTest
assertPreferencesEqual(UserPreferences.Unit, boolean, float, float, UserPreferences)
- Method in class junit.
UserPreferencesPanelTest
assertSelectionContains(HomeModel, Wall...)
- Method in class junit.
PlanComponentTest
assertTreeIsSorted(JTree)
- Method in class junit.
CatalogTreeSet
mehode de test junit assert si arbre trié
assertWallsAreJoined(Wall, Wall, Wall)
- Method in class junit.
PlanComponentTest
A
C
D
E
F
G
H
I
J
L
M
N
O
P
R
S
T
U
V
W
X
Y
Skip navigation links
Overview
Package
Class
Use
Tree
Deprecated
Index
Help
Prev Letter
Next Letter
Frames
No Frames
All Classes


Captain America
Steven Rogers
Iron Man
Tony Stark
Black Widow
Natasha Romanoff
Spider-Man
Peter Parker