XmlDataPath (webMethods Java API Reference)

java.lang.Object
- com.wm.xmldata.XmlDataPath

```
public class XmlDataPath
extends java.lang.Object
```
This helper class facilitates the encoding or decoding of an XmlData path as a String literal. A path is simply an array of XmDataContentTags that describe the navigation path from some element in an XmlData tree to some descendant element.
XmlDataContentTags that are used for navigation exploit tag features that are not exploited by Xml document types or by the XmlData helper class. These features are index specification (for repeating content) and content naming (for substitution groups and any wildcards). These features are only relevant when navigating an XmlData tree (for example using an XmlDataMap).
When a path is encoded as a String it is represented as a sequence of path steps, generally of the form /{id}prefix:ncname[index]. The [index} is specified only when accessing repeating content. The prefix: is specified only when elements are namespace-qualified. When a step requires content naming, and additional qualifier is appended, for example, /{2}*substitution-able{{1}baker} specifies a content tag for a substitution group that has a child element named 'baker'. In order to encode or decode a path literal, an XMlNamespaceMap must also be provided. The map may be specified in literal form, or an XmlNamespaceMap instance.
```
  Typical paths:
      /{1}able
      /{2}charlie[3]/{1}epsilon
      /{2}*group/{1}*any{{1}nsx:abc}
```
XmlDataCopy supports an additional other type of content-tag, the iterator-tag. The iterator-tag serves as a wild-card during copy. Iterator-tags must begin with the ! character and may be used as wildcard placeholders for full-names, indexes, or indirect-qualifiers. The name is purely symbolic and arbitrary; the only relevance of the symbolic name is that iterator-tag names on the input side are correspondingly matched with same-named tags on the output side by XmlDataCopy.
```
  Typical iterator-tag usage:
      /{1}name[!instance]/!item        !instance iterates of the index of the repeating value at {1}name while !item iterates over the full-names of each item in {1}name
      /{1}*any{!item}Name              !item is assigned the value-tag associated with {1}*any
```

Constructor Summary

Constructors
Constructor and Description

XmlDataPath()

Constructors
Constructor and Description
`XmlDataPath()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static XmlDataContentTag[]`	`createFromString(java.lang.String path)` Creates a path from a single String literal.
`static XmlDataContentTag[]`	`createFromString(java.lang.String path, java.lang.String prefixes)` Creates a Path (an array of XmlDataContentTags) from a path String literal and a namespace declaration String literal.
`static XmlDataContentTag[]`	`createFromString(java.lang.String path, XmlNamespaceMap map)` Creates an XmlDta path (an array of XmlDataContentTags) from a path String literal and an XmlNamespaceMap instance.
`static boolean`	`equals(XmlDataContentTag[] path1, XmlDataContentTag[] path2)` Tests the equality of two paths.
`static java.lang.String`	`getAsString(XmlDataContentTag[] tags, XmlNamespaceMap map)` Creates a path literal string using the specified path (array of XmlDataContentTags_ and XmlNamespaceMap.
`static java.lang.String`	`getAsStringWithMap(XmlDataContentTag[] tags)` Creates a path literal string and prepends a prefix map declaration.
`static java.lang.String`	`getAsStringWithMap(XmlDataContentTag[] tags, XmlNamespaceMap map)` Creates a path literal string and prepends a prefix map declaration.
`static XmlDataContentTag[]`	`removeLeaf(XmlDataContentTag[] tags)`

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - XmlDataPath
```
public XmlDataPath()
```
- Method Detail
  - createFromString
```
public static XmlDataContentTag[] createFromString(java.lang.String path,
                                                   java.lang.String prefixes)
```
    Creates a Path (an array of XmlDataContentTags) from a path String literal and a namespace declaration String literal.
    
    Parameters:
    
    path - path in literal form: e.g., {1}x:abc (where x is a declared prefix)
    
    prefixes - prefix declarations specified as space-separated list of prefixes and associated namespaces
    
    Returns:
    
    an XmlDataContetntTag array
  - createFromString
```
public static XmlDataContentTag[] createFromString(java.lang.String path,
                                                   XmlNamespaceMap map)
```
    Creates an XmlDta path (an array of XmlDataContentTags) from a path String literal and an XmlNamespaceMap instance.
    
    Parameters:
    
    path - string literal specifying the path
    
    map - a map specifying namespace prefix/URI associations
    
    Returns:
    
    an array of XmlDatContentTags
  - createFromString
```
public static XmlDataContentTag[] createFromString(java.lang.String path)
```
    Creates a path from a single String literal. If the String starts with a namespace declaration in the form {...}, it is removed from the head of the String and an XmlNamespaceMap is created from it. The remainder of the path string is treated as a literal path using the generated XmlNamespaceMap. If no {...} declaration is present, the path literal string may not use prefixed names and the path applies to unqualified names.
    
    Parameters:
    
    path - a String literal representation of path that does not require namespace qualification, or has an explicit map encoded in the literal
    
    Returns:
    
    an array of XmlDatContentTags
  - getAsString
```
public static java.lang.String getAsString(XmlDataContentTag[] tags,
                                           XmlNamespaceMap map)
```
    Creates a path literal string using the specified path (array of XmlDataContentTags_ and XmlNamespaceMap. The path literal does not include the {...} namespace declarations.
    
    Parameters:
    
    tags - a list of input tags
    
    map - the namespace map
    
    Returns:
    
    a path literal
  - getAsStringWithMap
```
public static java.lang.String getAsStringWithMap(XmlDataContentTag[] tags)
```
    Creates a path literal string and prepends a prefix map declaration. The prefix declarations are extracted from the tags using generated prefixes.
    
    Parameters:
    
    tags - input tags
    
    Returns:
    
    a path literal in the form :{prefix declarations}/step/step/step
  - getAsStringWithMap
```
public static java.lang.String getAsStringWithMap(XmlDataContentTag[] tags,
                                                  XmlNamespaceMap map)
```
    Creates a path literal string and prepends a prefix map declaration. The prefix declarations are extracted from the provided XmlNamespaceMap.
    
    Parameters:
    
    tags - input tags that define a path
    
    map - the input XmlNamespaceMap
    
    Returns:
    
    a path literal in the form :{prefix declarations}/step/step/step. If the namespace map is empty, the returned string is of form /step/step.../step
  - equals
```
public static boolean equals(XmlDataContentTag[] path1,
                             XmlDataContentTag[] path2)
```
    Tests the equality of two paths. Paths are equal if and only if they are the same length and each member also satisfies XmlDataContentTag.euals()/
    
    Parameters:
    
    path1 - A path defined by an XmlDataContentTag[].
    
    path2 - A path defined by an XmlDataCOntentTag[].
    
    Returns:
    
    true if the two paths are equal
  - removeLeaf
```
public static XmlDataContentTag[] removeLeaf(XmlDataContentTag[] tags)
```

Class XmlDataPath

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

XmlDataPath

Method Detail

createFromString

createFromString

createFromString

getAsString

getAsStringWithMap

getAsStringWithMap

equals

removeLeaf