0001    //
0002    //  SWXMLHash.swift
0003    //
0004    //  Copyright (c) 2014 David Mohundro
0005    //
0006    //  Permission is hereby granted, free of charge, to any person obtaining a copy
0007    //  of this software and associated documentation files (the "Software"), to deal
0008    //  in the Software without restriction, including without limitation the rights
0009    //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
0010    //  copies of the Software, and to permit persons to whom the Software is
0011    //  furnished to do so, subject to the following conditions:
0012    //
0013    //  The above copyright notice and this permission notice shall be included in
0014    //  all copies or substantial portions of the Software.
0015    //
0016    //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
0017    //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
0018    //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
0019    //  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
0020    //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
0021    //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
0022    //  THE SOFTWARE.
0023    
0024    import Foundation
0025    
0026    let rootElementNameSWXMLHash.swift:131     var root = XMLElement(name: rootElementName)
SWXMLHash.swift:147         root = XMLElement(name: rootElementName)
SWXMLHash.swift:207     var root = XMLElement(name: rootElementName)
SWXMLHash.swift:516             if elem.name == rootElementName { = "SWXMLHash_Root_Element"
0027    
0028    /// Parser options
0029    public class SWXMLHashOptionsSWXMLHash.swift:41     let options: SWXMLHashOptions
SWXMLHash.swift:43     private init(_ options: SWXMLHashOptions = SWXMLHashOptions()) {
SWXMLHash.swift:43     private init(_ options: SWXMLHashOptions = SWXMLHashOptions()) {
SWXMLHash.swift:47     class public func config(configAction: (SWXMLHashOptions) -> ()) -> SWXMLHash {
SWXMLHash.swift:48         let opts = SWXMLHashOptions()
SWXMLHash.swift:120     init(_ options: SWXMLHashOptions)
SWXMLHash.swift:126     required init(_ options: SWXMLHashOptions) {
SWXMLHash.swift:137     let options: SWXMLHashOptions
SWXMLHash.swift:202     required init(_ options: SWXMLHashOptions) {
SWXMLHash.swift:209     let options: SWXMLHashOptions {
0030        internal initSWXMLHash.swift:43     private init(_ options: SWXMLHashOptions = SWXMLHashOptions()) {
SWXMLHash.swift:48         let opts = SWXMLHashOptions()() {}
0031    
0032        /// determines whether to parse the XML with lazy parsing or not
0033        public var shouldProcessLazilySWXMLHash.swift:58         let parser: SimpleXmlParser = options.shouldProcessLazily ? LazyXMLParser(options) : XMLParser(options)
SWXMLHash.swift:89         return config { conf in conf.shouldProcessLazily = true }.parse(xml)
SWXMLHash.swift:99         return config { conf in conf.shouldProcessLazily = true }.parse(data) = false
0034    
0035        /// determines whether to parse XML namespaces or not (forwards to `NSXMLParser.shouldProcessNamespaces`)
0036        public var shouldProcessNamespacesSWXMLHash.swift:152         parser.shouldProcessNamespaces = options.shouldProcessNamespaces
SWXMLHash.swift:218         parser.shouldProcessNamespaces = options.shouldProcessNamespaces = false
0037    }
0038    
0039    /// Simple XML parser
0040    public class SWXMLHashSWXMLHash.swift:47     class public func config(configAction: (SWXMLHashOptions) -> ()) -> SWXMLHash {
SWXMLHash.swift:50         return SWXMLHash(opts)
SWXMLHash.swift:69         return SWXMLHash().parse(xml)
SWXMLHash.swift:79         return SWXMLHash().parse(data) {
0041        let optionsSWXMLHash.swift:44         self.options = options
SWXMLHash.swift:58         let parser: SimpleXmlParser = options.shouldProcessLazily ? LazyXMLParser(options) : XMLParser(options)
SWXMLHash.swift:58         let parser: SimpleXmlParser = options.shouldProcessLazily ? LazyXMLParser(options) : XMLParser(options)
SWXMLHash.swift:58         let parser: SimpleXmlParser = options.shouldProcessLazily ? LazyXMLParser(options) : XMLParser(options): SWXMLHashOptions
0042    
0043        private initSWXMLHash.swift:50         return SWXMLHash(opts)
SWXMLHash.swift:69         return SWXMLHash().parse(xml)
SWXMLHash.swift:79         return SWXMLHash().parse(data)(_ options: SWXMLHashOptions = SWXMLHashOptions()) {
0044            self.options = options
0045        }
0046    
0047        class public func configSWXMLHash.swift:89         return config { conf in conf.shouldProcessLazily = true }.parse(xml)
SWXMLHash.swift:99         return config { conf in conf.shouldProcessLazily = true }.parse(data)(configAction: (SWXMLHashOptions) -> ()) -> SWXMLHash {
0048            let opts = SWXMLHashOptions()
0049            configAction(opts)
0050            return SWXMLHash(opts)
0051        }
0052    
0053        public func parseSWXMLHash.swift:69         return SWXMLHash().parse(xml)
SWXMLHash.swift:89         return config { conf in conf.shouldProcessLazily = true }.parse(xml)(xml: String) -> XMLIndexer {
0054            return parse((xml as NSString).dataUsingEncoding(NSUTF8StringEncoding)!)
0055        }
0056    
0057        public func parseSWXMLHash.swift:54         return parse((xml as NSString).dataUsingEncoding(NSUTF8StringEncoding)!)
SWXMLHash.swift:79         return SWXMLHash().parse(data)
SWXMLHash.swift:99         return config { conf in conf.shouldProcessLazily = true }.parse(data)(data: NSData) -> XMLIndexer {
0058            let parser: SimpleXmlParser = options.shouldProcessLazily ? LazyXMLParser(options) : XMLParser(options)
0059            return parser.parse(data)
0060        }
0061    
0062        /**
0063        Method to parse XML passed in as a string.
0064    
0065        - parameter xml: The XML to be parsed
0066        - returns: An XMLIndexer instance that is used to look up elements in the XML
0067        */
0068        class public func parse(xml: String) -> XMLIndexer {
0069            return SWXMLHash().parse(xml)
0070        }
0071    
0072        /**
0073        Method to parse XML passed in as an NSData instance.
0074    
0075        - parameter xml: The XML to be parsed
0076        - returns: An XMLIndexer instance that is used to look up elements in the XML
0077        */
0078        class public func parse(data: NSData) -> XMLIndexer {
0079            return SWXMLHash().parse(data)
0080        }
0081    
0082        /**
0083        Method to lazily parse XML passed in as a string.
0084    
0085        - parameter xml: The XML to be parsed
0086        - returns: An XMLIndexer instance that is used to look up elements in the XML
0087        */
0088        class public func lazy(xml: String) -> XMLIndexer {
0089            return config { conf in conf.shouldProcessLazily = true }.parse(xml)
0090        }
0091    
0092        /**
0093        Method to lazily parse XML passed in as an NSData instance.
0094    
0095        - parameter xml: The XML to be parsed
0096        - returns: An XMLIndexer instance that is used to look up elements in the XML
0097        */
0098        class public func lazy(data: NSData) -> XMLIndexer {
0099            return config { conf in conf.shouldProcessLazily = true }.parse(data)
0100        }
0101    }
0102    
0103    struct StackSWXMLHash.swift:132     var parentStack = Stack<XMLElement>()
SWXMLHash.swift:133     var elementStack = Stack<String>()
SWXMLHash.swift:208     var parentStack = Stack<XMLElement>()<TSWXMLHash.swift:104     var items = [T]()
SWXMLHash.swift:105     mutating func push(item: T) {
SWXMLHash.swift:108     mutating func pop() -> T {
SWXMLHash.swift:114     func top() -> T {> {
0104        var itemsSWXMLHash.swift:106         items.append(item)
SWXMLHash.swift:109         return items.removeLast()
SWXMLHash.swift:112         items.removeAll(keepCapacity: false)
SWXMLHash.swift:115         return items[items.count - 1]
SWXMLHash.swift:115         return items[items.count - 1]
SWXMLHash.swift:191         if elementStack.items.count > ops.count {
SWXMLHash.swift:192             return elementStack.items.startsWith(ops.map { $0.key })
SWXMLHash.swift:195             return ops.map { $0.key }.startsWith(elementStack.items) = [T]()
0105        mutating func pushSWXMLHash.swift:148         parentStack.push(root)
SWXMLHash.swift:159         elementStack.push(elementName)
SWXMLHash.swift:165         parentStack.push(currentNode)
SWXMLHash.swift:215         parentStack.push(root)
SWXMLHash.swift:228         parentStack.push(currentNode)(item: T) {
0106            items.append(item)
0107        }
0108        mutating func popSWXMLHash.swift:181         elementStack.pop()
SWXMLHash.swift:184             parentStack.pop()
SWXMLHash.swift:238         parentStack.pop()() -> T {
0109            return items.removeLast()
0110        }
0111        mutating func removeAllSWXMLHash.swift:146         parentStack.removeAll()
SWXMLHash.swift:213         parentStack.removeAll()() {
0112            items.removeAll(keepCapacity: false)
0113        }
0114        func topSWXMLHash.swift:164         let currentNode = parentStack.top().addElement(elementName, withAttributes: attributeDict)
SWXMLHash.swift:173         let current = parentStack.top()
SWXMLHash.swift:227         let currentNode = parentStack.top().addElement(elementName, withAttributes: attributeDict)
SWXMLHash.swift:232         let current = parentStack.top()() -> T {
0115            return items[items.count - 1]
0116        }
0117    }
0118    
0119    protocol SimpleXmlParserSWXMLHash.swift:58         let parser: SimpleXmlParser = options.shouldProcessLazily ? LazyXMLParser(options) : XMLParser(options)
SWXMLHash.swift:125 class LazyXMLParser: NSObject, SimpleXmlParser, NSXMLParserDelegate {
SWXMLHash.swift:201 class XMLParser: NSObject, SimpleXmlParser, NSXMLParserDelegate { {
0120        init(_ options: SWXMLHashOptions)
0121        func parseSWXMLHash.swift:59         return parser.parse(data)(data: NSData) -> XMLIndexer
0122    }
0123    
0124    /// The implementation of NSXMLParserDelegate and where the lazy parsing actually happens.
0125    class LazyXMLParserSWXMLHash.swift:58         let parser: SimpleXmlParser = options.shouldProcessLazily ? LazyXMLParser(options) : XMLParser(options)
SWXMLHash.swift:263     let parser: LazyXMLParser
SWXMLHash.swift:265     init(parser: LazyXMLParser) {
SWXMLHash.swift:392         case let value as LazyXMLParser:
SWXMLHash.swift:403     init(_ stream: LazyXMLParser) {: NSObject, SimpleXmlParser, NSXMLParserDelegate {
0126        required initSWXMLHash.swift:58         let parser: SimpleXmlParser = options.shouldProcessLazily ? LazyXMLParser(options) : XMLParser(options)(_ options: SWXMLHashOptions) {
0127            self.options = options
0128            super.init()
0129        }
0130    
0131        var rootSWXMLHash.swift:147         root = XMLElement(name: rootElementName)
SWXMLHash.swift:148         parentStack.push(root)
SWXMLHash.swift:271         let indexer = XMLIndexer(parser.root) = XMLElement(name: rootElementName)
0132        var parentStackSWXMLHash.swift:146         parentStack.removeAll()
SWXMLHash.swift:148         parentStack.push(root)
SWXMLHash.swift:164         let currentNode = parentStack.top().addElement(elementName, withAttributes: attributeDict)
SWXMLHash.swift:165         parentStack.push(currentNode)
SWXMLHash.swift:173         let current = parentStack.top()
SWXMLHash.swift:184             parentStack.pop() = Stack<XMLElement>()
0133        var elementStackSWXMLHash.swift:159         elementStack.push(elementName)
SWXMLHash.swift:181         elementStack.pop()
SWXMLHash.swift:191         if elementStack.items.count > ops.count {
SWXMLHash.swift:192             return elementStack.items.startsWith(ops.map { $0.key })
SWXMLHash.swift:195             return ops.map { $0.key }.startsWith(elementStack.items) = Stack<String>()
0134    
0135        var dataSWXMLHash.swift:140         self.data = data
SWXMLHash.swift:151         let parser = NSXMLParser(data: data!): NSData?
0136        var opsSWXMLHash.swift:150         self.ops = ops
SWXMLHash.swift:191         if elementStack.items.count > ops.count {
SWXMLHash.swift:192             return elementStack.items.startsWith(ops.map { $0.key })
SWXMLHash.swift:195             return ops.map { $0.key }.startsWith(elementStack.items): [IndexOp] = []
0137        let optionsSWXMLHash.swift:127         self.options = options
SWXMLHash.swift:152         parser.shouldProcessNamespaces = options.shouldProcessNamespaces: SWXMLHashOptions
0138    
0139        func parse(data: NSData) -> XMLIndexer {
0140            self.data = data
0141            return XMLIndexer(self)
0142        }
0143    
0144        func startParsingSWXMLHash.swift:270         parser.startParsing(ops)(ops: [IndexOp]) {
0145            // clear any prior runs of parse... expected that this won't be necessary, but you never know
0146            parentStack.removeAll()
0147            root = XMLElement(name: rootElementName)
0148            parentStack.push(root)
0149    
0150            self.ops = ops
0151            let parser = NSXMLParser(data: data!)
0152            parser.shouldProcessNamespaces = options.shouldProcessNamespaces
0153            parser.delegate = self
0154            parser.parse()
0155        }
0156    
0157        func parser(parser: NSXMLParser, didStartElement elementName: String, namespaceURI: String?, qualifiedName qName: String?, attributes attributeDict: [String: String]) {
0158    
0159            elementStack.push(elementName)
0160    
0161            if !onMatch() {
0162                return
0163            }
0164            let currentNode = parentStack.top().addElement(elementName, withAttributes: attributeDict)
0165            parentStack.push(currentNode)
0166        }
0167    
0168        func parser(parser: NSXMLParser, foundCharacters string: String) {
0169            if !onMatch() {
0170                return
0171            }
0172    
0173            let current = parentStack.top()
0174    
0175            current.addText(string)
0176        }
0177    
0178        func parser(parser: NSXMLParser, didEndElement elementName: String, namespaceURI: String?, qualifiedName qName: String?) {
0179            let match = onMatch()
0180    
0181            elementStack.pop()
0182    
0183            if match {
0184                parentStack.pop()
0185            }
0186        }
0187    
0188        func onMatchSWXMLHash.swift:161         if !onMatch() {
SWXMLHash.swift:169         if !onMatch() {
SWXMLHash.swift:179         let match = onMatch()() -> Bool {
0189            // we typically want to compare against the elementStack to see if it matches ops, *but*
0190            // if we're on the first element, we'll instead compare the other direction.
0191            if elementStack.items.count > ops.count {
0192                return elementStack.items.startsWith(ops.map { $0.key })
0193            }
0194            else {
0195                return ops.map { $0.key }.startsWith(elementStack.items)
0196            }
0197        }
0198    }
0199    
0200    /// The implementation of NSXMLParserDelegate and where the parsing actually happens.
0201    class XMLParserSWXMLHash.swift:58         let parser: SimpleXmlParser = options.shouldProcessLazily ? LazyXMLParser(options) : XMLParser(options): NSObject, SimpleXmlParser, NSXMLParserDelegate {
0202        required initSWXMLHash.swift:58         let parser: SimpleXmlParser = options.shouldProcessLazily ? LazyXMLParser(options) : XMLParser(options)(_ options: SWXMLHashOptions) {
0203            self.options = options
0204            super.init()
0205        }
0206    
0207        var rootSWXMLHash.swift:215         parentStack.push(root)
SWXMLHash.swift:222         return XMLIndexer(root) = XMLElement(name: rootElementName)
0208        var parentStackSWXMLHash.swift:213         parentStack.removeAll()
SWXMLHash.swift:215         parentStack.push(root)
SWXMLHash.swift:227         let currentNode = parentStack.top().addElement(elementName, withAttributes: attributeDict)
SWXMLHash.swift:228         parentStack.push(currentNode)
SWXMLHash.swift:232         let current = parentStack.top()
SWXMLHash.swift:238         parentStack.pop() = Stack<XMLElement>()
0209        let optionsSWXMLHash.swift:203         self.options = options
SWXMLHash.swift:218         parser.shouldProcessNamespaces = options.shouldProcessNamespaces: SWXMLHashOptions
0210    
0211        func parse(data: NSData) -> XMLIndexer {
0212            // clear any prior runs of parse... expected that this won't be necessary, but you never know
0213            parentStack.removeAll()
0214    
0215            parentStack.push(root)
0216    
0217            let parser = NSXMLParser(data: data)
0218            parser.shouldProcessNamespaces = options.shouldProcessNamespaces
0219            parser.delegate = self
0220            parser.parse()
0221    
0222            return XMLIndexer(root)
0223        }
0224    
0225        func parser(parser: NSXMLParser, didStartElement elementName: String, namespaceURI: String?, qualifiedName qName: String?, attributes attributeDict: [String: String]) {
0226    
0227            let currentNode = parentStack.top().addElement(elementName, withAttributes: attributeDict)
0228            parentStack.push(currentNode)
0229        }
0230    
0231        func parser(parser: NSXMLParser, foundCharacters string: String) {
0232            let current = parentStack.top()
0233    
0234            current.addText(string)
0235        }
0236    
0237        func parser(parser: NSXMLParser, didEndElement elementName: String, namespaceURI: String?, qualifiedName qName: String?) {
0238            parentStack.pop()
0239        }
0240    }
0241    
0242    public class IndexOpSWXMLHash.swift:136     var ops: [IndexOp] = []
SWXMLHash.swift:144     func startParsing(ops: [IndexOp]) {
SWXMLHash.swift:261     var ops: [IndexOp] = []
SWXMLHash.swift:418             let op = IndexOp(key) {
0243        var indexSWXMLHash.swift:248         self.index = -1
SWXMLHash.swift:252         if index >= 0 {
SWXMLHash.swift:253             return key + " " + index.description
SWXMLHash.swift:275             if op.index >= 0 {
SWXMLHash.swift:276                 childIndex = childIndex[op.index]
SWXMLHash.swift:463             opStream.ops[opStream.ops.count - 1].index = index: Int
0244        let keySWXMLHash.swift:192             return elementStack.items.startsWith(ops.map { $0.key })
SWXMLHash.swift:195             return ops.map { $0.key }.startsWith(elementStack.items)
SWXMLHash.swift:247         self.key = key
SWXMLHash.swift:253             return key + " " + index.description
SWXMLHash.swift:256         return key
SWXMLHash.swift:274             childIndex = childIndex[op.key]: String
0245    
0246        initSWXMLHash.swift:418             let op = IndexOp(key)(_ key: String) {
0247            self.key = key
0248            self.index = -1
0249        }
0250    
0251        func toStringSWXMLHash.swift:286             s += "[" + op.toString() + "]"() -> String {
0252            if index >= 0 {
0253                return key + " " + index.description
0254            }
0255    
0256            return key
0257        }
0258    }
0259    
0260    public class IndexOpsSWXMLHash.swift:296     case Stream(IndexOps)
SWXMLHash.swift:393             self = .Stream(IndexOps(parser: value))
SWXMLHash.swift:404         self = .Stream(IndexOps(parser: stream)) {
0261        var opsSWXMLHash.swift:270         parser.startParsing(ops)
SWXMLHash.swift:273         for op in ops {
SWXMLHash.swift:279         ops.removeAll(keepCapacity: false)
SWXMLHash.swift:285         for op in ops {
SWXMLHash.swift:419             opStream.ops.append(op)
SWXMLHash.swift:463             opStream.ops[opStream.ops.count - 1].index = index
SWXMLHash.swift:463             opStream.ops[opStream.ops.count - 1].index = index: [IndexOp] = []
0262    
0263        let parserSWXMLHash.swift:266         self.parser = parser
SWXMLHash.swift:270         parser.startParsing(ops)
SWXMLHash.swift:271         let indexer = XMLIndexer(parser.root): LazyXMLParser
0264    
0265        initSWXMLHash.swift:393             self = .Stream(IndexOps(parser: value))
SWXMLHash.swift:404         self = .Stream(IndexOps(parser: stream))(parser: LazyXMLParser) {
0266            self.parser = parser
0267        }
0268    
0269        func findElementsSWXMLHash.swift:314             let list = ops.findElements()
SWXMLHash.swift:333             let list = ops.findElements()
SWXMLHash.swift:362             let match = opStream.findElements()() -> XMLIndexer {
0270            parser.startParsing(ops)
0271            let indexer = XMLIndexer(parser.root)
0272            var childIndex = indexer
0273            for op in ops {
0274                childIndex = childIndex[op.key]
0275                if op.index >= 0 {
0276                    childIndex = childIndex[op.index]
0277                }
0278            }
0279            ops.removeAll(keepCapacity: false)
0280            return childIndex
0281        }
0282    
0283        func stringifySWXMLHash.swift:361             opStream.stringify()() -> String {
0284            var s = ""
0285            for op in ops {
0286                s += "[" + op.toString() + "]"
0287            }
0288            return s
0289        }
0290    }
0291    
0292    /// Returned from SWXMLHash, allows easy element lookup into XML data.
0293    public enum XMLIndexerSWXMLHash.swift:53     public func parse(xml: String) -> XMLIndexer {
SWXMLHash.swift:57     public func parse(data: NSData) -> XMLIndexer {
SWXMLHash.swift:68     class public func parse(xml: String) -> XMLIndexer {
SWXMLHash.swift:78     class public func parse(data: NSData) -> XMLIndexer {
SWXMLHash.swift:88     class public func lazy(xml: String) -> XMLIndexer {
SWXMLHash.swift:98     class public func lazy(data: NSData) -> XMLIndexer {
SWXMLHash.swift:121     func parse(data: NSData) -> XMLIndexer
SWXMLHash.swift:139     func parse(data: NSData) -> XMLIndexer {
SWXMLHash.swift:141         return XMLIndexer(self)
SWXMLHash.swift:211     func parse(data: NSData) -> XMLIndexer {
SWXMLHash.swift:222         return XMLIndexer(root)
SWXMLHash.swift:269     func findElements() -> XMLIndexer {
SWXMLHash.swift:271         let indexer = XMLIndexer(parser.root)
SWXMLHash.swift:325             var xmlList = [XMLIndexer]()
SWXMLHash.swift:327                 xmlList.append(XMLIndexer(elem))
SWXMLHash.swift:331             return [XMLIndexer(elem)]
SWXMLHash.swift:322     public var all: [XMLIndexer] {
SWXMLHash.swift:342         var list = [XMLIndexer]()
SWXMLHash.swift:345                 list.append(XMLIndexer(elem))
SWXMLHash.swift:341     public var children: [XMLIndexer] {
SWXMLHash.swift:358     public func withAttr(attr: String, _ value: String) throws -> XMLIndexer {
SWXMLHash.swift:415     public func byKey(key: String) throws -> XMLIndexer {
SWXMLHash.swift:460     public func byIndex(index: Int) throws -> XMLIndexer {
SWXMLHash.swift:490     typealias GeneratorType = XMLIndexer
SWXMLHash.swift:492     public func generate() -> IndexingGenerator<[XMLIndexer]> {
SWXMLHash.swift:498 extension XMLIndexer: BooleanType {
SWXMLHash.swift:510 extension XMLIndexer: CustomStringConvertible {
SWXMLHash.swift:527 extension XMLIndexer.Error: CustomStringConvertible {: SequenceType {
0294        case ElementSWXMLHash.swift:311         case .Element(let elem):
SWXMLHash.swift:330         case .Element(let elem):
SWXMLHash.swift:366                 return .Element(elem)
SWXMLHash.swift:369         case .Element(let elem):
SWXMLHash.swift:372                     return .Element(elem)
SWXMLHash.swift:391             self = .Element(value)
SWXMLHash.swift:400         self = .Element(el)
SWXMLHash.swift:421         case .Element(let elem):
SWXMLHash.swift:425                     return .Element(match[0])
SWXMLHash.swift:467                 return .Element(list[index])
SWXMLHash.swift:470         case .Element(let elem):
SWXMLHash.swift:472                 return .Element(elem)
SWXMLHash.swift:515         case .Element(let elem):(XMLElement)
0295        case ListSWXMLHash.swift:324         case .List(let list):
SWXMLHash.swift:364         case .List(let list):
SWXMLHash.swift:428                     return .List(match)
SWXMLHash.swift:465         case .List(let list):
SWXMLHash.swift:513         case .List(let list):([XMLElement])
0296        case StreamSWXMLHash.swift:313         case .Stream(let ops):
SWXMLHash.swift:332         case .Stream(let ops):
SWXMLHash.swift:360         case .Stream(let opStream):
SWXMLHash.swift:393             self = .Stream(IndexOps(parser: value))
SWXMLHash.swift:404         self = .Stream(IndexOps(parser: stream))
SWXMLHash.swift:417         case .Stream(let opStream):
SWXMLHash.swift:420             return .Stream(opStream)
SWXMLHash.swift:462         case .Stream(let opStream):
SWXMLHash.swift:464             return .Stream(opStream)(IndexOps)
0297        case XMLErrorSWXMLHash.swift:447             return .XMLError(error)
SWXMLHash.swift:449             return .XMLError(.Key(key: key))
SWXMLHash.swift:469             return .XMLError(.Index(idx: index))
SWXMLHash.swift:476             return .XMLError(.Index(idx: index))
SWXMLHash.swift:484             return .XMLError(error)
SWXMLHash.swift:486             return .XMLError(.Index(idx: index))
SWXMLHash.swift:502         case .XMLError:(Error)
0298    
0299        public enum ErrorSWXMLHash.swift:297     case XMLError(Error)
SWXMLHash.swift:368             throw Error.AttributeValue(attr: attr, value: value)
SWXMLHash.swift:374                 throw Error.AttributeValue(attr: attr, value: value)
SWXMLHash.swift:378             throw Error.Attribute(attr: attr)
SWXMLHash.swift:395             throw Error.Init(instance: rawObject)
SWXMLHash.swift:433             throw Error.Key(key: key)
SWXMLHash.swift:446         } catch let error as Error {
SWXMLHash.swift:483         }  catch let error as Error {
SWXMLHash.swift:527 extension XMLIndexer.Error: CustomStringConvertible {: ErrorType {
0300            case AttributeSWXMLHash.swift:378             throw Error.Attribute(attr: attr)
SWXMLHash.swift:530         case .Attribute(let attr):(attr: String)
0301            case AttributeValueSWXMLHash.swift:368             throw Error.AttributeValue(attr: attr, value: value)
SWXMLHash.swift:374                 throw Error.AttributeValue(attr: attr, value: value)
SWXMLHash.swift:532         case .AttributeValue(let attr, let value):(attr: String, value: String)
0302            case KeySWXMLHash.swift:433             throw Error.Key(key: key)
SWXMLHash.swift:449             return .XMLError(.Key(key: key))
SWXMLHash.swift:534         case .Key(let key):(key: String)
0303            case IndexSWXMLHash.swift:469             return .XMLError(.Index(idx: index))
SWXMLHash.swift:476             return .XMLError(.Index(idx: index))
SWXMLHash.swift:486             return .XMLError(.Index(idx: index))
SWXMLHash.swift:536         case .Index(let index):(idx: Int)
0304            case InitSWXMLHash.swift:395             throw Error.Init(instance: rawObject)
SWXMLHash.swift:538         case .Init(let instance):(instance: AnyObject)
0305            case ErrorSWXMLHash.swift:540         case .Error:
0306        }
0307    
0308        /// The underlying XMLElement at the currently indexed level of XML.
0309        public var elementSWXMLHash.swift:315             return list.element
SWXMLHash.swift:343         for elem in all.map({ $0.element! }).flatMap({ $0 }) {: XMLElement? {
0310            switch self {
0311            case .Element(let elem):
0312                return elem
0313            case .Stream(let ops):
0314                let list = ops.findElements()
0315                return list.element
0316            default:
0317                return nil
0318            }
0319        }
0320    
0321        /// All elements at the currently indexed level
0322        public var allSWXMLHash.swift:334             return list.all
SWXMLHash.swift:343         for elem in all.map({ $0.element! }).flatMap({ $0 }) {
SWXMLHash.swift:493         return all.generate(): [XMLIndexer] {
0323            switch self {
0324            case .List(let list):
0325                var xmlList = [XMLIndexer]()
0326                for elem in list {
0327                    xmlList.append(XMLIndexer(elem))
0328                }
0329                return xmlList
0330            case .Element(let elem):
0331                return [XMLIndexer(elem)]
0332            case .Stream(let ops):
0333                let list = ops.findElements()
0334                return list.all
0335            default:
0336                return []
0337            }
0338        }
0339    
0340        /// All child elements from the currently indexed level
0341        public var children: [XMLIndexer] {
0342            var list = [XMLIndexer]()
0343            for elem in all.map({ $0.element! }).flatMap({ $0 }) {
0344                for elem in elem.xmlChildren {
0345                    list.append(XMLIndexer(elem))
0346                }
0347            }
0348            return list
0349        }
0350    
0351        /**
0352        Allows for element lookup by matching attribute values.
0353    
0354        - parameter attr: should the name of the attribute to match on
0355        - parameter value: should be the value of the attribute to match on
0356        - returns: instance of XMLIndexer
0357        */
0358        public func withAttrSWXMLHash.swift:363             return try match.withAttr(attr, value)(attr: String, _ value: String) throws -> XMLIndexer {
0359            switch self {
0360            case .Stream(let opStream):
0361                opStream.stringify()
0362                let match = opStream.findElements()
0363                return try match.withAttr(attr, value)
0364            case .List(let list):
0365                if let elem = list.filter({$0.attributes[attr] == value}).first {
0366                    return .Element(elem)
0367                }
0368                throw Error.AttributeValue(attr: attr, value: value)
0369            case .Element(let elem):
0370                if let attr = elem.attributes[attr] {
0371                    if attr == value {
0372                        return .Element(elem)
0373                    }
0374                    throw Error.AttributeValue(attr: attr, value: value)
0375                }
0376                fallthrough
0377            default:
0378                throw Error.Attribute(attr: attr)
0379            }
0380        }
0381    
0382        /**
0383        Initializes the XMLIndexer
0384    
0385        - parameter _: should be an instance of XMLElement, but supports other values for error handling
0386        - returns: instance of XMLIndexer
0387        */
0388        public init(_ rawObject: AnyObject) throws {
0389            switch rawObject {
0390            case let value as XMLElement:
0391                self = .Element(value)
0392            case let value as LazyXMLParser:
0393                self = .Stream(IndexOps(parser: value))
0394            default:
0395                throw Error.Init(instance: rawObject)
0396            }
0397        }
0398    
0399        public initSWXMLHash.swift:222         return XMLIndexer(root)
SWXMLHash.swift:271         let indexer = XMLIndexer(parser.root)
SWXMLHash.swift:327                 xmlList.append(XMLIndexer(elem))
SWXMLHash.swift:331             return [XMLIndexer(elem)]
SWXMLHash.swift:345                 list.append(XMLIndexer(elem))(_ el: XMLElement) {
0400            self = .Element(el)
0401        }
0402    
0403        initSWXMLHash.swift:141         return XMLIndexer(self)(_ stream: LazyXMLParser) {
0404            self = .Stream(IndexOps(parser: stream))
0405        }
0406    
0407        /**
0408        Find an XML element at the current level by element name
0409    
0410        - parameter key: The element name to index by
0411        - returns: instance of XMLIndexer to match the element (or elements) found by key
0412        - throws: Throws an XMLIndexerError.Key if no element was found
0413        - TODO: Change to throwing subscripts if available in futher releases
0414        */
0415        public func byKeySWXMLHash.swift:445            return try self.byKey(key)(key: String) throws -> XMLIndexer {
0416            switch self {
0417            case .Stream(let opStream):
0418                let op = IndexOp(key)
0419                opStream.ops.append(op)
0420                return .Stream(opStream)
0421            case .Element(let elem):
0422                let match = elem.xmlChildren.filter({ $0.name == key })
0423                if match.count > 0 {
0424                    if match.count == 1 {
0425                        return .Element(match[0])
0426                    }
0427                    else {
0428                        return .List(match)
0429                    }
0430                }
0431                fallthrough
0432            default:
0433                throw Error.Key(key: key)
0434            }
0435        }
0436    
0437        /**
0438        Find an XML element at the current level by element name
0439    
0440        - parameter key: The element name to index by
0441        - returns: instance of XMLIndexer to match the element (or elements) found by
0442        */
0443        public subscriptSWXMLHash.swift:274             childIndex = childIndex[op.key](key: String) -> XMLIndexer {
0444            do {
0445               return try self.byKey(key)
0446            } catch let error as Error {
0447                return .XMLError(error)
0448            } catch {
0449                return .XMLError(.Key(key: key))
0450            }
0451        }
0452    
0453        /**
0454        Find an XML element by index within a list of XML Elements at the current level
0455    
0456        - parameter index: The 0-based index to index by
0457        - returns: instance of XMLIndexer to match the element (or elements) found by key
0458        - TODO: Change to throwing subscripts if available in futher releases
0459        */
0460        public func byIndexSWXMLHash.swift:482             return try byIndex(index)(index: Int) throws -> XMLIndexer {
0461            switch self {
0462            case .Stream(let opStream):
0463                opStream.ops[opStream.ops.count - 1].index = index
0464                return .Stream(opStream)
0465            case .List(let list):
0466                if index <= list.count {
0467                    return .Element(list[index])
0468                }
0469                return .XMLError(.Index(idx: index))
0470            case .Element(let elem):
0471                if index == 0 {
0472                    return .Element(elem)
0473                }
0474                fallthrough
0475            default:
0476                return .XMLError(.Index(idx: index))
0477            }
0478        }
0479    
0480        public subscriptSWXMLHash.swift:276                 childIndex = childIndex[op.index](index: Int) -> XMLIndexer {
0481            do {
0482                return try byIndex(index)
0483            }  catch let error as Error {
0484                return .XMLError(error)
0485            } catch {
0486                return .XMLError(.Index(idx: index))
0487            }
0488        }
0489    
0490        typealias GeneratorType = XMLIndexer
0491    
0492        public func generate() -> IndexingGenerator<[XMLIndexer]> {
0493            return all.generate()
0494        }
0495    }
0496    
0497    /// XMLIndexer extensions
0498    extension XMLIndexer: BooleanType {
0499        /// True if a valid XMLIndexer, false if an error type
0500        public var boolValue: Bool {
0501            switch self {
0502            case .XMLError:
0503                return false
0504            default:
0505                return true
0506            }
0507        }
0508    }
0509    
0510    extension XMLIndexer: CustomStringConvertible {
0511        public var description: String {
0512            switch self {
0513            case .List(let list):
0514                return list.map { $0.description }.joinWithSeparator("")
0515            case .Element(let elem):
0516                if elem.name == rootElementName {
0517                    return elem.children.map { $0.description }.joinWithSeparator("")
0518                }
0519    
0520                return elem.description
0521            default:
0522                return ""
0523            }
0524        }
0525    }
0526    
0527    extension XMLIndexer.Error: CustomStringConvertible {
0528        public var description: String {
0529            switch self {
0530            case .Attribute(let attr):
0531                return "XML Attribute Error: Missing attribute [\"\(attr)\"]"
0532            case .AttributeValue(let attr, let value):
0533                return "XML Attribute Error: Missing attribute [\"\(attr)\"] with value [\"\(value)\"]"
0534            case .Key(let key):
0535                return "XML Element Error: Incorrect key [\"\(key)\"]"
0536            case .Index(let index):
0537                return "XML Element Error: Incorrect index [\"\(index)\"]"
0538            case .Init(let instance):
0539                return "XML Indexer Error: initialization with Object [\"\(instance)\"]"
0540            case .Error:
0541                return "Unknown Error"
0542            }
0543        }
0544    }
0545    
0546    /// Models content for an XML doc, whether it is text or XML
0547    public protocol XMLContentSWXMLHash.swift:551 public class TextElement: XMLContent {
SWXMLHash.swift:559 public class XMLElement: XMLContent {
SWXMLHash.swift:570     var children = [XMLContent](): CustomStringConvertible {
0548    }
0549    
0550    /// Models a text element
0551    public class TextElementSWXMLHash.swift:567         return children.map({ $0 as? TextElement }).flatMap({ $0 }).reduce("", combine: { $0 + $1!.text })
SWXMLHash.swift:613         let elem = TextElement(text: text)
SWXMLHash.swift:619 extension TextElement: CustomStringConvertible {: XMLContent {
0552        public let textSWXMLHash.swift:554         self.text = text
SWXMLHash.swift:567         return children.map({ $0 as? TextElement }).flatMap({ $0 }).reduce("", combine: { $0 + $1!.text })
SWXMLHash.swift:621         return text: String
0553        initSWXMLHash.swift:613         let elem = TextElement(text: text)(text: String) {
0554            self.text = text
0555        }
0556    }
0557    
0558    /// Models an XML element, including name, text and attributes
0559    public class XMLElementSWXMLHash.swift:131     var root = XMLElement(name: rootElementName)
SWXMLHash.swift:132     var parentStack = Stack<XMLElement>()
SWXMLHash.swift:147         root = XMLElement(name: rootElementName)
SWXMLHash.swift:207     var root = XMLElement(name: rootElementName)
SWXMLHash.swift:208     var parentStack = Stack<XMLElement>()
SWXMLHash.swift:294     case Element(XMLElement)
SWXMLHash.swift:295     case List([XMLElement])
SWXMLHash.swift:309     public var element: XMLElement? {
SWXMLHash.swift:390         case let value as XMLElement:
SWXMLHash.swift:399     public init(_ el: XMLElement) {
SWXMLHash.swift:575         return children.map { $0 as? XMLElement }.flatMap { $0 }
SWXMLHash.swift:574     var xmlChildren: [XMLElement] {
SWXMLHash.swift:596     func addElement(name: String, withAttributes attributes: NSDictionary) -> XMLElement {
SWXMLHash.swift:597         let element = XMLElement(name: name, index: count)
SWXMLHash.swift:625 extension XMLElement: CustomStringConvertible {: XMLContent {
0560        /// The name of the element
0561        public let nameSWXMLHash.swift:422             let match = elem.xmlChildren.filter({ $0.name == key })
SWXMLHash.swift:516             if elem.name == rootElementName {
SWXMLHash.swift:585         self.name = name
SWXMLHash.swift:641             xmlReturn.append("<\(name)\(attributesString)>")
SWXMLHash.swift:645             xmlReturn.append("</\(name)>")
SWXMLHash.swift:650             return "<\(name)\(attributesString)>\(text!)</\(name)>"
SWXMLHash.swift:650             return "<\(name)\(attributesString)>\(text!)</\(name)>"
SWXMLHash.swift:653             return "<\(name)\(attributesString)/>": String
0562        /// The attributes of the element
0563        public var attributesSWXMLHash.swift:365             if let elem = list.filter({$0.attributes[attr] == value}).first {
SWXMLHash.swift:370             if let attr = elem.attributes[attr] {
SWXMLHash.swift:605                 element.attributes[key] = value
SWXMLHash.swift:628         if !attributes.isEmpty {
SWXMLHash.swift:629             for (key, val) in attributes { = [String:String]()
0564    
0565        /// The inner text of the element, if it exists
0566        public var textSWXMLHash.swift:649         if text != nil {
SWXMLHash.swift:650             return "<\(name)\(attributesString)>\(text!)</\(name)>": String? {
0567            return children.map({ $0 as? TextElement }).flatMap({ $0 }).reduce("", combine: { $0 + $1!.text })
0568        }
0569    
0570        var childrenSWXMLHash.swift:517                 return elem.children.map { $0.description }.joinWithSeparator("")
SWXMLHash.swift:567         return children.map({ $0 as? TextElement }).flatMap({ $0 }).reduce("", combine: { $0 + $1!.text })
SWXMLHash.swift:575         return children.map { $0 as? XMLElement }.flatMap { $0 }
SWXMLHash.swift:600         children.append(element)
SWXMLHash.swift:615         children.append(elem)
SWXMLHash.swift:639         if children.count > 0 {
SWXMLHash.swift:642             for child in children { = [XMLContent]()
0571        var countSWXMLHash.swift:597         let element = XMLElement(name: name, index: count)
SWXMLHash.swift:598         count += 1: Int = 0
0572        var indexSWXMLHash.swift:586         self.index = index: Int
0573    
0574        var xmlChildrenSWXMLHash.swift:344             for elem in elem.xmlChildren {
SWXMLHash.swift:422             let match = elem.xmlChildren.filter({ $0.name == key }): [XMLElement] {
0575            return children.map { $0 as? XMLElement }.flatMap { $0 }
0576        }
0577    
0578        /**
0579        Initialize an XMLElement instance
0580    
0581        -parameter name: The name of the element to be initialized
0582        -returns: a new instance of XMLElement
0583        */
0584        initSWXMLHash.swift:131     var root = XMLElement(name: rootElementName)
SWXMLHash.swift:147         root = XMLElement(name: rootElementName)
SWXMLHash.swift:207     var root = XMLElement(name: rootElementName)
SWXMLHash.swift:597         let element = XMLElement(name: name, index: count)(name: String, index: Int = 0) {
0585            self.name = name
0586            self.index = index
0587        }
0588    
0589        /**
0590        Adds a new XMLElement underneath this instance of XMLElement
0591    
0592        - parameter name: The name of the new element to be added
0593        - parameter withAttributes: The attributes dictionary for the element being added
0594        - returns: The XMLElement that has now been added
0595        */
0596        func addElementSWXMLHash.swift:164         let currentNode = parentStack.top().addElement(elementName, withAttributes: attributeDict)
SWXMLHash.swift:227         let currentNode = parentStack.top().addElement(elementName, withAttributes: attributeDict)(name: String, withAttributes attributes: NSDictionary) -> XMLElement {
0597            let element = XMLElement(name: name, index: count)
0598            count += 1
0599    
0600            children.append(element)
0601    
0602            for (keyAny,valueAny) in attributes {
0603                if let key = keyAny as? String,
0604                    let value = valueAny as? String {
0605                    element.attributes[key] = value
0606                }
0607            }
0608    
0609            return element
0610        }
0611    
0612        func addTextSWXMLHash.swift:175         current.addText(string)
SWXMLHash.swift:234         current.addText(string)(text: String) {
0613            let elem = TextElement(text: text)
0614    
0615            children.append(elem)
0616        }
0617    }
0618    
0619    extension TextElement: CustomStringConvertible {
0620        public var description: String {
0621            return text
0622        }
0623    }
0624    
0625    extension XMLElement: CustomStringConvertible {
0626        public var descriptionSWXMLHash.swift:514             return list.map { $0.description }.joinWithSeparator("")
SWXMLHash.swift:520             return elem.description: String {
0627            var attributesStringList = [String]()
0628            if !attributes.isEmpty {
0629                for (key, val) in attributes {
0630                    attributesStringList.append("\(key)=\"\(val)\"")
0631                }
0632            }
0633    
0634            var attributesString = attributesStringList.joinWithSeparator(" ")
0635            if !attributesString.isEmpty {
0636                attributesString = " " + attributesString
0637            }
0638    
0639            if children.count > 0 {
0640                var xmlReturn = [String]()
0641                xmlReturn.append("<\(name)\(attributesString)>")
0642                for child in children {
0643                    xmlReturn.append(child.description)
0644                }
0645                xmlReturn.append("</\(name)>")
0646                return xmlReturn.joinWithSeparator("")
0647            }
0648    
0649            if text != nil {
0650                return "<\(name)\(attributesString)>\(text!)</\(name)>"
0651            }
0652            else {
0653                return "<\(name)\(attributesString)/>"
0654            }
0655        }
0656    }
0657

SWXMLHash.swift:131	var root = XMLElement(name: rootElementName)
SWXMLHash.swift:147	root = XMLElement(name: rootElementName)
SWXMLHash.swift:207	var root = XMLElement(name: rootElementName)
SWXMLHash.swift:516	if elem.name == rootElementName {

SWXMLHash.swift:41	let options: SWXMLHashOptions
SWXMLHash.swift:43	private init(_ options: SWXMLHashOptions = SWXMLHashOptions()) {
SWXMLHash.swift:43	private init(_ options: SWXMLHashOptions = SWXMLHashOptions()) {
SWXMLHash.swift:47	class public func config(configAction: (SWXMLHashOptions) -> ()) -> SWXMLHash {
SWXMLHash.swift:48	let opts = SWXMLHashOptions()
SWXMLHash.swift:120	init(_ options: SWXMLHashOptions)
SWXMLHash.swift:126	required init(_ options: SWXMLHashOptions) {
SWXMLHash.swift:137	let options: SWXMLHashOptions
SWXMLHash.swift:202	required init(_ options: SWXMLHashOptions) {
SWXMLHash.swift:209	let options: SWXMLHashOptions

SWXMLHash.swift:152	parser.shouldProcessNamespaces = options.shouldProcessNamespaces
SWXMLHash.swift:218	parser.shouldProcessNamespaces = options.shouldProcessNamespaces

SWXMLHash.swift:47	class public func config(configAction: (SWXMLHashOptions) -> ()) -> SWXMLHash {
SWXMLHash.swift:50	return SWXMLHash(opts)
SWXMLHash.swift:69	return SWXMLHash().parse(xml)
SWXMLHash.swift:79	return SWXMLHash().parse(data)

SWXMLHash.swift:44	self.options = options
SWXMLHash.swift:58	let parser: SimpleXmlParser = options.shouldProcessLazily ? LazyXMLParser(options) : XMLParser(options)
SWXMLHash.swift:58	let parser: SimpleXmlParser = options.shouldProcessLazily ? LazyXMLParser(options) : XMLParser(options)
SWXMLHash.swift:58	let parser: SimpleXmlParser = options.shouldProcessLazily ? LazyXMLParser(options) : XMLParser(options)

SWXMLHash.swift:89	return config { conf in conf.shouldProcessLazily = true }.parse(xml)
SWXMLHash.swift:99	return config { conf in conf.shouldProcessLazily = true }.parse(data)

SWXMLHash.swift:69	return SWXMLHash().parse(xml)
SWXMLHash.swift:89	return config { conf in conf.shouldProcessLazily = true }.parse(xml)

SWXMLHash.swift:54	return parse((xml as NSString).dataUsingEncoding(NSUTF8StringEncoding)!)
SWXMLHash.swift:79	return SWXMLHash().parse(data)
SWXMLHash.swift:99	return config { conf in conf.shouldProcessLazily = true }.parse(data)

SWXMLHash.swift:132	var parentStack = Stack<XMLElement>()
SWXMLHash.swift:133	var elementStack = Stack<String>()
SWXMLHash.swift:208	var parentStack = Stack<XMLElement>()

SWXMLHash.swift:104	var items = [T]()
SWXMLHash.swift:105	mutating func push(item: T) {
SWXMLHash.swift:108	mutating func pop() -> T {
SWXMLHash.swift:114	func top() -> T {

SWXMLHash.swift:161	if !onMatch() {
SWXMLHash.swift:169	if !onMatch() {
SWXMLHash.swift:179	let match = onMatch()

SWXMLHash.swift:106	items.append(item)
SWXMLHash.swift:109	return items.removeLast()
SWXMLHash.swift:112	items.removeAll(keepCapacity: false)
SWXMLHash.swift:115	return items[items.count - 1]
SWXMLHash.swift:115	return items[items.count - 1]
SWXMLHash.swift:191	if elementStack.items.count > ops.count {
SWXMLHash.swift:192	return elementStack.items.startsWith(ops.map { $0.key })
SWXMLHash.swift:195	return ops.map { $0.key }.startsWith(elementStack.items)

SWXMLHash.swift:148	parentStack.push(root)
SWXMLHash.swift:159	elementStack.push(elementName)
SWXMLHash.swift:165	parentStack.push(currentNode)
SWXMLHash.swift:215	parentStack.push(root)
SWXMLHash.swift:228	parentStack.push(currentNode)

SWXMLHash.swift:181	elementStack.pop()
SWXMLHash.swift:184	parentStack.pop()
SWXMLHash.swift:238	parentStack.pop()

SWXMLHash.swift:146	parentStack.removeAll()
SWXMLHash.swift:213	parentStack.removeAll()

SWXMLHash.swift:164	let currentNode = parentStack.top().addElement(elementName, withAttributes: attributeDict)
SWXMLHash.swift:173	let current = parentStack.top()
SWXMLHash.swift:227	let currentNode = parentStack.top().addElement(elementName, withAttributes: attributeDict)
SWXMLHash.swift:232	let current = parentStack.top()

SWXMLHash.swift:58	let parser: SimpleXmlParser = options.shouldProcessLazily ? LazyXMLParser(options) : XMLParser(options)
SWXMLHash.swift:263	let parser: LazyXMLParser
SWXMLHash.swift:265	init(parser: LazyXMLParser) {
SWXMLHash.swift:392	case let value as LazyXMLParser:
SWXMLHash.swift:403	init(_ stream: LazyXMLParser) {

SWXMLHash.swift:147	root = XMLElement(name: rootElementName)
SWXMLHash.swift:148	parentStack.push(root)
SWXMLHash.swift:271	let indexer = XMLIndexer(parser.root)

SWXMLHash.swift:146	parentStack.removeAll()
SWXMLHash.swift:148	parentStack.push(root)
SWXMLHash.swift:164	let currentNode = parentStack.top().addElement(elementName, withAttributes: attributeDict)
SWXMLHash.swift:165	parentStack.push(currentNode)
SWXMLHash.swift:173	let current = parentStack.top()
SWXMLHash.swift:184	parentStack.pop()

SWXMLHash.swift:159	elementStack.push(elementName)
SWXMLHash.swift:181	elementStack.pop()
SWXMLHash.swift:191	if elementStack.items.count > ops.count {
SWXMLHash.swift:192	return elementStack.items.startsWith(ops.map { $0.key })
SWXMLHash.swift:195	return ops.map { $0.key }.startsWith(elementStack.items)

SWXMLHash.swift:140	self.data = data
SWXMLHash.swift:151	let parser = NSXMLParser(data: data!)

SWXMLHash.swift:150	self.ops = ops
SWXMLHash.swift:191	if elementStack.items.count > ops.count {
SWXMLHash.swift:192	return elementStack.items.startsWith(ops.map { $0.key })
SWXMLHash.swift:195	return ops.map { $0.key }.startsWith(elementStack.items)

SWXMLHash.swift:127	self.options = options
SWXMLHash.swift:152	parser.shouldProcessNamespaces = options.shouldProcessNamespaces

SWXMLHash.swift:215	parentStack.push(root)
SWXMLHash.swift:222	return XMLIndexer(root)

SWXMLHash.swift:203	self.options = options
SWXMLHash.swift:218	parser.shouldProcessNamespaces = options.shouldProcessNamespaces

SWXMLHash.swift:136	var ops: [IndexOp] = []
SWXMLHash.swift:144	func startParsing(ops: [IndexOp]) {
SWXMLHash.swift:261	var ops: [IndexOp] = []
SWXMLHash.swift:418	let op = IndexOp(key)

SWXMLHash.swift:248	self.index = -1
SWXMLHash.swift:252	if index >= 0 {
SWXMLHash.swift:253	return key + " " + index.description
SWXMLHash.swift:275	if op.index >= 0 {
SWXMLHash.swift:276	childIndex = childIndex[op.index]
SWXMLHash.swift:463	opStream.ops[opStream.ops.count - 1].index = index

SWXMLHash.swift:296	case Stream(IndexOps)
SWXMLHash.swift:393	self = .Stream(IndexOps(parser: value))
SWXMLHash.swift:404	self = .Stream(IndexOps(parser: stream))

SWXMLHash.swift:270	parser.startParsing(ops)
SWXMLHash.swift:273	for op in ops {
SWXMLHash.swift:279	ops.removeAll(keepCapacity: false)
SWXMLHash.swift:285	for op in ops {
SWXMLHash.swift:419	opStream.ops.append(op)
SWXMLHash.swift:463	opStream.ops[opStream.ops.count - 1].index = index
SWXMLHash.swift:463	opStream.ops[opStream.ops.count - 1].index = index

SWXMLHash.swift:266	self.parser = parser
SWXMLHash.swift:270	parser.startParsing(ops)
SWXMLHash.swift:271	let indexer = XMLIndexer(parser.root)

SWXMLHash.swift:314	let list = ops.findElements()
SWXMLHash.swift:333	let list = ops.findElements()
SWXMLHash.swift:362	let match = opStream.findElements()