objective c - Ejemplo simple de NSXMLParser

objective-c swift

Question

La mayoría de los ejemplos de cómo invocar NSXMLParser están contenidos en proyectos complejos que involucran aplicaciones. ¿Qué aspecto tiene un ejemplo simple que demuestra las devoluciones de llamada?

Answer 1

Aquí hay una versión Swift del código Objective-C original a continuación.

Fue construido y probado usando XCode 7.3. Al escribir al delegado, me pareció muy útil copiar los prototipos de función de la documentación. Vale la pena señalar que Swift es actualmente un objetivo en movimiento bastante rápido.

main.swift

import Foundation

// Let''s go
print("Main: Started")

// Try to load the file. Display the description of the error if one occurs
var xmlData : NSData
do {
    xmlData = try NSData(contentsOfFile: "/Users/amt/Documents/TestXml/Test.xml",
                         options: .DataReadingMappedIfSafe)
}
catch let error as NSError {
    print("Main: /(error.description)")

    exit(1)
}

// Create a parser and point it at the NSData object containing
// the file we just loaded
var parser : NSXMLParser! = NSXMLParser(data: xmlData)

// Create a parser delegate object and assign it to the parser
// Beware the "weak" reference and don''t try to combine the two lines
// of code into one unless you like EXC_BAD_ACCESS exceptions
var parserDelegate : MyXmlParserDelegate = MyXmlParserDelegate()
parser.delegate = parserDelegate

// This example also illustrates some of the namespace functions defined in
// the delegate protocol so enable namespace reporting to see them invoked
parser.shouldReportNamespacePrefixes = true

// Parse the document
if !parser.parse() {
    // If parse() returned false then an error occurred so display is location
    // and details
    let error = parser.parserError
    let line = parser.lineNumber
    let col = parser.columnNumber
    print("Parsing failed at /(line):/(col): /(error?.localizedDescription)")
}

// All done
print("Main: Ended")
exit(0)

MyXmlParserDelegate.swift

import Foundation

class MyXmlParserDelegate:NSObject, NSXMLParserDelegate {

    @objc func parserDidStartDocument(parser: NSXMLParser) {
        print("parserDidStartDocument")
    }

    @objc func parser(parser: NSXMLParser, didStartElement elementName: String,
               namespaceURI: String?, qualifiedName qName: String?,
               attributes attributeDict: [String : String]) {
        print("didStartElement       --> /(elementName)")
    }

    @objc func parser(parser: NSXMLParser, foundCharacters string: String) {
        print("foundCharacters       --> /(string)")
    }

    @objc func parser(parser: NSXMLParser, didEndElement elementName: String,
               namespaceURI: String?, qualifiedName qName: String?) {
        print("didEndElement         --> /(elementName)")
    }

    @objc func parser(parser: NSXMLParser, didStartMappingPrefix prefix: String,
               toURI namespaceURI: String) {
        print("didStartMappingPrefix --> Prefix: /(prefix) toURI: /(namespaceURI)")
    }

    @objc func parser(parser: NSXMLParser, didEndMappingPrefix prefix: String) {
        print("didEndMappingPrefix   --> Prefix: /(prefix)")
    }

    @objc func parserDidEndDocument(parser: NSXMLParser) {
        print("parserDidEndDocument")
    }
}

Answer 2

Como parte de la exploración de NSXMLParser, creé el siguiente código realmente simple.

main.m

int main(int argc, const char * argv[])
{

    @autoreleasepool {
        NSLog(@"Main Started");

        NSError *error = nil;

        // Load the file and check the result
        NSData *data = [NSData dataWithContentsOfFile:@"/Users/Tim/Documents/MusicXml/Small.xml"
                                          options:NSDataReadingUncached
                                            error:&error];
        if(error) {
            NSLog(@"Error %@", error);

            return 1;
        }


        // Create a parser and point it at the NSData object containing the file we just loaded
        NSXMLParser *parser = [[NSXMLParser alloc] initWithData:data];

        // Create an instance of our parser delegate and assign it to the parser
        MyXmlParserDelegate *parserDelegate = [[MyXmlParserDelegate alloc] init];
        [parser setDelegate:parserDelegate];

        // Invoke the parser and check the result
        [parser parse];
        error = [parser parserError];
        if(error)
        {
            NSLog(@"Error %@", error);

            return 1;
        }

        // All done
        NSLog(@"Main Ended");
    }
    return 0;
}

MyXmlParserDelegate.h

#import <Foundation/Foundation.h>

@interface MyXmlParserDelegate : NSObject <NSXMLParserDelegate>

@end

MyXmlParserDelegate.m

#import "MyXmlParserDelegate.h"

@implementation MyXmlParserDelegate

- (void) parserDidStartDocument:(NSXMLParser *)parser {
    NSLog(@"parserDidStartDocument");
}

- (void)parser:(NSXMLParser *)parser didStartElement:(NSString *)elementName namespaceURI:(NSString *)namespaceURI qualifiedName:(NSString *)qName attributes:(NSDictionary *)attributeDict {
    NSLog(@"didStartElement --> %@", elementName);
}

-(void) parser:(NSXMLParser *)parser foundCharacters:(NSString *)string {
    NSLog(@"foundCharacters --> %@", string);
}

- (void)parser:(NSXMLParser *)parser didEndElement:(NSString *)elementName namespaceURI:(NSString *)namespaceURI qualifiedName:(NSString *)qName {
    NSLog(@"didEndElement   --> %@", elementName);
}

- (void) parserDidEndDocument:(NSXMLParser *)parser {
    NSLog(@"parserDidEndDocument");
}
@end

Lo publiqué con la esperanza de que ayude a alguien más.

Answer 3

Ejemplo de Swift 4: análisis del archivo Xib.

import Foundation

class XMLTransformer: NSObject {

   private let parser: XMLParser
   private var stack = [Node]()
   private var tree: Node?

   init(data: Data) {
      parser = XMLParser(data: data)
      super.init()
      parser.delegate = self
   }
}

extension XMLTransformer {

   func transform() throws -> Node? {
      parser.parse()
      if let e = parser.parserError {
         throw e
      }
      assert(stack.isEmpty)
      assert(tree != nil)
      return tree
   }

}

extension XMLTransformer: XMLParserDelegate {

   func parser(_ parser: XMLParser, didStartElement elementName: String, namespaceURI: String?, qualifiedName qName: String?, attributes attributeDict: [String : String] = [:]) {
      guard let tag = Tag(rawValue: elementName) else {
         return
      }
      let node = Node(tag: tag, attributes: attributeDict, nodes: [])
      stack.append(node)
   }

   func parser(_ parser: XMLParser, didEndElement elementName: String, namespaceURI: String?, qualifiedName qName: String?) {
      guard let tag = Tag(rawValue: elementName) else {
         return
      }
      let lastElement = stack.removeLast()
      assert(lastElement.tag == tag)
      if let last = stack.last {
         last.nodes += [lastElement]
      } else {
         tree = lastElement
      }
   }
}

extension XMLTransformer {

   enum Tag: String {
      case document
      case objects
      case tableViewCell, tableViewCellContentView
      case subviews
      case mapView
      case constraints, constraint
      case connections, outlet
   }
}

extension XMLTransformer {

   class Node {

      let tag: Tag
      let attributes: [String : String]
      var nodes: [Node]

      init(tag: Tag, attributes: [String : String], nodes: [Node] = []) {
         self.tag = tag
         self.attributes = attributes
         self.nodes = nodes
      }
   }
}

Uso:

let data = try xib(named: "MapTableViewCell")
let c = XMLTransformer(data: data)
let tree = try c.transform() // Here you have parsed XML in a Tree representation.