Options

import FoundationXML

class XMLNode

convenience init(kind: XMLNode.Kind)

init(kind: XMLNode.Kind, options: XMLNode.Options = [])

class func attribute(withName name: String, stringValue: String) -> Any

class func attribute(withName name: String, uri: String, stringValue: String) -> Any

class func comment(withStringValue stringValue: String) -> Any

class func document() -> Any

class func document(withRootElement element: XMLElement) -> Any

class func dtdNode(withXMLString string: String) -> Any?

class func element(withName name: String) -> Any

class func element(withName name: String, children: [XMLNode]?, attributes: [XMLNode]?) -> Any

class func element(withName name: String, stringValue string: String) -> Any

class func element(withName name: String, uri: String) -> Any

class func localName(forName name: String) -> String

class func namespace(withName name: String, stringValue: String) -> Any

class func predefinedNamespace(forPrefix name: String) -> XMLNode?

class func prefix(forName name: String) -> String?

class func processingInstruction(withName name: String, stringValue: String) -> Any

class func text(withStringValue stringValue: String) -> Any

var childCount: Int { get }

var children: [XMLNode]? { get }

override var description: String { get }

var endIndex: XMLNode.Index { get }

var index: Int { get }

var kind: XMLNode.Kind { get }

var level: Int { get }

var localName: String? { get }

var name: String? { get set }

var next: XMLNode? { get }

var nextSibling: XMLNode? { get }

var objectValue: Any? { get set }

var parent: XMLNode? { get }

var prefix: String? { get }

var previous: XMLNode? { get }

var previousSibling: XMLNode? { get }

var rootDocument: XMLDocument? { get }

var startIndex: XMLNode.Index { get }

var stringValue: String? { get set }

var uri: String? { get set }

var xPath: String? { get }

var xmlString: String { get }

subscript(index: XMLNode.Index) -> XMLNode { get }

func canonicalXMLStringPreservingComments(_ comments: Bool) -> String

func child(at index: Int) -> XMLNode?

override func copy() -> Any

func copy(with zone: NSZone? = nil) -> Any

func detach()

func index(after i: XMLNode.Index) -> XMLNode.Index

func nodes(forXPath xpath: String) throws -> [XMLNode]

func setStringValue(_ string: String, resolvingEntities resolve: Bool)

func xmlString(options: XMLNode.Options) -> String

struct Index

enum Kind

override convenience init()

protocol Equatable

A type that can be compared for value equality.

protocol ExpressibleByArrayLiteral

A type that can be initialized using an array literal.

protocol OptionSet : RawRepresentable, SetAlgebra

A type that presents a mathematical set interface to a bit set.

protocol RawRepresentable<RawValue>

A type that can be converted to and from an associated raw value.

protocol Sendable

A thread-safe type whose values can be shared across arbitrary concurrent contexts without introducing a risk of data races. Values of the type may have no shared mutable state, or they may protect that state with a lock or by forcing it to only be accessed from a specific actor.

protocol SetAlgebra<Element> : Equatable, ExpressibleByArrayLiteral

A type that provides mathematical set operations.

init(rawValue: UInt)

static let documentIncludeContentTypeDeclaration: XMLNode.Options

static let documentTidyHTML: XMLNode.Options

static let documentTidyXML: XMLNode.Options

static let documentValidate: XMLNode.Options

static let documentXInclude: XMLNode.Options

static let nodeCompactEmptyElement: XMLNode.Options

static let nodeExpandEmptyElement: XMLNode.Options

static let nodeIsCDATA: XMLNode.Options

static let nodeLoadExternalEntitiesAlways: XMLNode.Options

static let nodeLoadExternalEntitiesNever: XMLNode.Options

static let nodeLoadExternalEntitiesSameOriginOnly: XMLNode.Options

static let nodeNeverEscapeContents: XMLNode.Options

static let nodePreserveAll: XMLNode.Options

static let nodePreserveAttributeOrder: XMLNode.Options

static let nodePreserveCDATA: XMLNode.Options

static let nodePreserveCharacterReferences: XMLNode.Options

static let nodePreserveDTD: XMLNode.Options

static let nodePreserveEmptyElements: XMLNode.Options

static let nodePreserveEntities: XMLNode.Options

static let nodePreserveNamespaceOrder: XMLNode.Options

static let nodePreservePrefixes: XMLNode.Options

static let nodePreserveQuotes: XMLNode.Options

static let nodePreserveWhitespace: XMLNode.Options

static let nodePrettyPrint: XMLNode.Options

static let nodePromoteSignificantWhitespace: XMLNode.Options

static let nodeUseDoubleQuotes: XMLNode.Options

static let nodeUseSingleQuotes: XMLNode.Options

let rawValue: UInt

init()

Creates an empty option set.

init<S>(_ sequence: S) where S : Sequence, Self.Element == S.Element

Creates a new set from a finite sequence of items.

init(arrayLiteral: Self.Element...)

Creates a set containing the elements of the given array literal.

var isEmpty: Bool { get }

A Boolean value that indicates whether the set has no elements.

static func != (lhs: Self, rhs: Self) -> Bool

Returns a Boolean value indicating whether two values are not equal.

func contains(_ member: Self) -> Bool

Returns a Boolean value that indicates whether a given element is a member of the option set.

mutating func formIntersection(_ other: Self)

Removes all elements of this option set that are not also present in the given set.

mutating func formSymmetricDifference(_ other: Self)

Replaces this set with a new set containing all elements contained in either this set or the given set, but not in both.

mutating func formUnion(_ other: Self)

Inserts the elements of another set into this option set.

@discardableResult mutating func insert(_ newMember: Self.Element) -> (inserted: Bool, memberAfterInsert: Self.Element)

Adds the given element to the option set if it is not already a member.

func intersection(_ other: Self) -> Self

Returns a new option set with only the elements contained in both this set and the given set.

func isDisjoint(with other: Self) -> Bool

Returns a Boolean value that indicates whether the set has no members in common with the given set.

func isStrictSubset(of other: Self) -> Bool

Returns a Boolean value that indicates whether this set is a strict subset of the given set.

func isStrictSuperset(of other: Self) -> Bool

Returns a Boolean value that indicates whether this set is a strict superset of the given set.

func isSubset(of other: Self) -> Bool

Returns a Boolean value that indicates whether the set is a subset of another set.

func isSuperset(of other: Self) -> Bool

Returns a Boolean value that indicates whether the set is a superset of the given set.

@discardableResult mutating func remove(_ member: Self.Element) -> Self.Element?

Removes the given element and all elements subsumed by it.

mutating func subtract(_ other: Self)

Removes the elements of the given set from this set.

func subtracting(_ other: Self) -> Self

Returns a new set containing the elements of this set that do not occur in the given set.

func symmetricDifference(_ other: Self) -> Self

Returns a new option set with the elements contained in this set or in the given set, but not in both.

func union(_ other: Self) -> Self

Returns a new option set of the elements contained in this set, in the given set, or in both.

@discardableResult mutating func update(with newMember: Self.Element) -> Self.Element?

Inserts the given element into the set.