/FSKit/Source/Common/enunciate/prod/reservation.m
Objective C | 2536 lines | 1368 code | 340 blank | 828 comment | 226 complexity | 7066d686f659256214dee0a9adbfdf3e MD5 | raw file
Possible License(s): BSD-3-Clause
Large files files are truncated, but you can click here to view the full file
1#import <reservation.h> 2 3/** 4 * Enunciate-specific C functions. 5 */ 6#ifndef ENUNCIATE_C_UTILITIES 7#define ENUNCIATE_C_UTILITIES 8 9/*******************xml utilities************************************/ 10 11static int xmlTextReaderAdvanceToNextStartOrEndElement(xmlTextReaderPtr reader) { 12 int status = xmlTextReaderRead(reader); 13 while (status && xmlTextReaderNodeType(reader) != XML_READER_TYPE_ELEMENT && xmlTextReaderNodeType(reader) != XML_READER_TYPE_END_ELEMENT) { 14 status = xmlTextReaderRead(reader); 15 } 16 return status; 17} 18 19static int xmlTextReaderSkipElement(xmlTextReaderPtr reader) { 20 int status = xmlTextReaderNext(reader); 21 while (status && xmlTextReaderNodeType(reader) != XML_READER_TYPE_ELEMENT && xmlTextReaderNodeType(reader) != XML_READER_TYPE_END_ELEMENT) { 22 status = xmlTextReaderRead(reader); 23 } 24 return status; 25} 26 27static xmlChar *xmlTextReaderReadEntireNodeValue(xmlTextReaderPtr reader) { 28 xmlChar *buffer = calloc(1, sizeof(xmlChar)); 29 const xmlChar *snippet; 30 int status; 31 if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ATTRIBUTE) { 32 return xmlTextReaderValue(reader); 33 } 34 else if (xmlTextReaderIsEmptyElement(reader) == 0) { 35 status = xmlTextReaderRead(reader); 36 while (status && (xmlTextReaderNodeType(reader) == XML_READER_TYPE_TEXT || xmlTextReaderNodeType(reader) == XML_READER_TYPE_CDATA || xmlTextReaderNodeType(reader) == XML_READER_TYPE_ENTITY_REFERENCE)) { 37 snippet = xmlTextReaderConstValue(reader); 38 buffer = realloc(buffer, (xmlStrlen(buffer) + xmlStrlen(snippet) + 1) * sizeof(xmlChar)); 39 xmlStrcat(buffer, snippet); 40 status = xmlTextReaderRead(reader); 41 } 42 } 43 return buffer; 44} 45 46/*******************base 64 utilities************************************/ 47 48/* 49 * Base64 Translation Table as described in RFC1113. 50 * 51 * This code was graciously ripped from http://base64.sourceforge.net 52 */ 53static const char cb64[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; 54 55/* 56 * Base64 Translation Table to decode (created by author) 57 * 58 * This code was graciously ripped from http://base64.sourceforge.net 59 */ 60static const char cd64[]="|$$$}rstuvwxyz{$$$$$$$>?@ABCDEFGHIJKLMNOPQRSTUVW$$$$$$XYZ[\\]^_`abcdefghijklmnopq"; 61 62/* 63 * encode 3 8-bit binary bytes as 4 '6-bit' characters 64 * 65 * This code was graciously ripped from http://base64.sourceforge.net 66 * 67 * @param in the block to encode 68 * @param out the block to encode to 69 * @param len the length of the 'in' block. 70 */ 71static void _encode_base64_block(unsigned char in[3], unsigned char out[4], int len) { 72 out[0] = cb64[ in[0] >> 2 ]; 73 out[1] = cb64[ ((in[0] & 0x03) << 4) | ((in[1] & 0xf0) >> 4) ]; 74 out[2] = (unsigned char) (len > 1 ? cb64[ ((in[1] & 0x0f) << 2) | ((in[2] & 0xc0) >> 6) ] : '='); 75 out[3] = (unsigned char) (len > 2 ? cb64[ in[2] & 0x3f ] : '='); 76} 77 78/* 79 * decode 4 '6-bit' characters into 3 8-bit binary bytes 80 * 81 * This code was graciously ripped from http://base64.sourceforge.net 82 */ 83static void _decode_base64_block( unsigned char in[4], unsigned char out[3] ) 84{ 85 out[ 0 ] = (unsigned char ) (in[0] << 2 | in[1] >> 4); 86 out[ 1 ] = (unsigned char ) (in[1] << 4 | in[2] >> 2); 87 out[ 2 ] = (unsigned char ) (((in[2] << 6) & 0xc0) | in[3]); 88} 89 90/* 91 * base64 encode a stream adding padding and line breaks as per spec. 92 * 93 * This code was graciously ripped from http://base64.sourceforge.net 94 * 95 * @param instream The stream to encode. 96 * @param insize The size of the stream to encode. 97 * @return The encoded string. 98 */ 99xmlChar *_encode_base64(unsigned char *instream, int insize) { 100 unsigned char in[3]; 101 unsigned char out[4]; 102 xmlChar *encoded; 103 int i, in_index = 0, out_index = 0, blocklen; 104 105 if (insize == 0) { 106 return BAD_CAST "\0"; 107 } 108 109 encoded = calloc(((insize / 3) * 4) + 10, sizeof(xmlChar)); 110 while (in_index <= insize) { 111 blocklen = 0; 112 for (i = 0; i < 3; i++) { 113 in[i] = instream[in_index++]; 114 if (in_index <= insize) { 115 blocklen++; 116 } 117 else { 118 in[i] = 0; 119 } 120 } 121 if (blocklen) { 122 _encode_base64_block(in, out, blocklen); 123 for( i = 0; i < 4; i++ ) { 124 encoded[out_index++] = out[i]; 125 } 126 } 127 } 128 129 return encoded; 130} 131 132/* 133 * Decode a base64 encoded stream discarding padding, line breaks and noise 134 * 135 * This code was graciously ripped from http://base64.sourceforge.net 136 * 137 * @param invalue The string to decode. 138 * @param outsize Holder for the length of the returned data. 139 * @return The decoded data. 140 */ 141unsigned char *_decode_base64( const xmlChar *invalue, int *outsize ) { 142 xmlChar in[4]; 143 unsigned char out[3], v; 144 int i, in_index = 0, out_index = 0, blocklen; 145 unsigned char *outstream; 146 147 if (invalue == NULL) { 148 return NULL; 149 } 150 151 outstream = calloc(((xmlStrlen(invalue) / 4) * 3) + 1, sizeof(unsigned char)); 152 while (invalue[in_index] != '\0') { 153 for (blocklen = 0, i = 0; i < 4 && invalue[in_index]; i++) { 154 v = 0; 155 while (invalue[in_index] != '\0' && v == 0) { 156 v = (unsigned char) invalue[in_index++]; 157 v = (unsigned char) ((v < 43 || v > 122) ? 0 : cd64[ v - 43 ]); 158 if (v) { 159 v = (unsigned char) ((v == '$') ? 0 : v - 61); 160 } 161 } 162 163 if (invalue[in_index] != '\0') { 164 blocklen++; 165 if (v) { 166 in[i] = (unsigned char) (v - 1); 167 } 168 } 169 else { 170 in[i] = 0; 171 } 172 } 173 174 if (blocklen) { 175 _decode_base64_block( in, out ); 176 for( i = 0; i < blocklen - 1; i++ ) { 177 outstream[out_index++] = out[i]; 178 } 179 } 180 } 181 182 if (outsize != NULL) { 183 *outsize = out_index; 184 } 185 186 return outstream; 187} 188 189#endif /* ENUNCIATE_C_UTILITIES */ 190 191#ifndef ENUNCIATE_OBJC_CLASSES 192#define ENUNCIATE_OBJC_CLASSES 193 194/** 195 * Protocol defining a JAXB (see https://jaxb.dev.java.net/) type. 196 */ 197@protocol JAXBType 198 199/** 200 * Read an XML type from an XML reader. 201 * 202 * @param reader The reader. 203 * @return An instance of the object defining the JAXB type. 204 */ 205+ (id<JAXBType>) readXMLType: (xmlTextReaderPtr) reader; 206 207/** 208 * Initialize the object with an XML reader. 209 * 210 * @param reader The XML reader from which to initialize the values of this type. 211 */ 212- (id) initWithReader: (xmlTextReaderPtr) reader; 213 214/** 215 * Write this instance of a JAXB type to a writer. 216 * 217 * @param writer The writer. 218 */ 219- (void) writeXMLType: (xmlTextWriterPtr) writer; 220 221@end /*protocol JAXBType*/ 222 223 224/** 225 * Protocol defining a JAXB (see https://jaxb.dev.java.net/) element. 226 */ 227@protocol JAXBElement 228 229/** 230 * Read the XML element from an XML reader. It is assumed 231 * that the reader is pointing at the start element (be careful 232 * that it's not still pointing to the XML document). 233 * 234 * @param reader The reader. 235 * @return An instance of the object defining the JAXB element. 236 */ 237+ (id<JAXBElement>) readXMLElement: (xmlTextReaderPtr) reader; 238 239/** 240 * Write this instance of a JAXB element to a writer. 241 * 242 * @param writer The writer. 243 */ 244- (void) writeXMLElement: (xmlTextWriterPtr) writer; 245 246/** 247 * Write this instance of a JAXB element to a writer. 248 * 249 * @param writer The writer. 250 * @param writeNs Whether to write the namespaces for this element to the xml writer. 251 */ 252- (void) writeXMLElement: (xmlTextWriterPtr) writer writeNamespaces: (BOOL) writeNs; 253 254@end /*protocol JAXBElement*/ 255 256 257/** 258 * Protocol defining methods for events that occur 259 * when reading/parsing XML. Intended for internal 260 * use only. 261 */ 262@protocol JAXBReading 263 264/** 265 * Method for reading an attribute. 266 * 267 * @param reader The reader pointing to the attribute. 268 * @return Whether the attribute was read. 269 */ 270- (BOOL) readJAXBAttribute: (xmlTextReaderPtr) reader; 271 272/** 273 * Method for reading the value of an element. 274 * 275 * @param reader The reader pointing to the element containing a value. 276 * @return Whether the value was read. 277 */ 278- (BOOL) readJAXBValue: (xmlTextReaderPtr) reader; 279 280/** 281 * Method for reading a child element. If (and only if) the child 282 * element was handled, the element in the reader should be 283 * "consumed" and the reader will be pointing to the end element. 284 * 285 * @param reader The reader pointing to the child element. 286 * @return Whether the child element was read. 287 */ 288- (BOOL) readJAXBChildElement: (xmlTextReaderPtr) reader; 289 290/** 291 * Method for reading an unknown attribute. 292 * 293 * @param reader The reader pointing to the unknown attribute. 294 * @return Whether the attribute was read. 295 */ 296- (void) readUnknownJAXBAttribute: (xmlTextReaderPtr) reader; 297 298/** 299 * Method for reading an unknown child element. Implementations 300 * must be responsible for "consuming" the child element. 301 * 302 * @param reader The reader pointing to the unknown child element. 303 * @return The status of the reader after having consumed the unknown child element. 304 */ 305- (int) readUnknownJAXBChildElement: (xmlTextReaderPtr) reader; 306 307@end /*protocol JAXBReading*/ 308 309/** 310 * Protocol defining methods for events that occur 311 * when writing XML. Intended for internal 312 * use only. 313 */ 314@protocol JAXBWriting 315 316/** 317 * Method for writing the attributes. 318 * 319 * @param writer The writer. 320 */ 321- (void) writeJAXBAttributes: (xmlTextWriterPtr) writer; 322 323/** 324 * Method for writing the element value. 325 * 326 * @param writer The writer. 327 */ 328- (void) writeJAXBValue: (xmlTextWriterPtr) writer; 329 330/** 331 * Method for writing the child elements. 332 * 333 * @param writer The writer. 334 */ 335- (void) writeJAXBChildElements: (xmlTextWriterPtr) writer; 336 337@end /*protocol JAXBWriting*/ 338 339/** 340 * Declaration of the JAXB type, element, events for a base object. 341 */ 342@interface NSObject (JAXB) <JAXBType, JAXBElement, JAXBReading, JAXBWriting> 343 344@end 345 346/** 347 * Implementation of the JAXB type, element, events for a base object. 348 */ 349@implementation NSObject (JAXB) 350 351/** 352 * Read the XML type from the reader; an instance of NSXMLElement. 353 * 354 * @param reader The reader. 355 * @return An instance of NSXMLElement 356 */ 357+ (id<JAXBType>) readXMLType: (xmlTextReaderPtr) reader 358{ 359 return [JAXBBasicXMLNode readXMLType: reader]; 360} 361 362/** 363 * Read an XML type from an XML reader into an existing instance. 364 * 365 * @param reader The reader. 366 * @param existing The existing instance into which to read values. 367 */ 368- (id) initWithReader: (xmlTextReaderPtr) reader 369{ 370 int status, depth; 371 if ((self = [self init])) { 372 if (xmlTextReaderHasAttributes(reader)) { 373 while (xmlTextReaderMoveToNextAttribute(reader)) { 374 if ([self readJAXBAttribute: reader] == NO) { 375 [self readUnknownJAXBAttribute: reader]; 376 } 377 } 378 379 status = xmlTextReaderMoveToElement(reader); 380 if (!status) { 381 //panic: unable to return to the element node. 382 [NSException raise: @"XMLReadError" 383 format: @"Error moving back to element position from attributes."]; 384 } 385 } 386 387 if ([self readJAXBValue: reader] == NO) { 388 //no value handled; attempt to process child elements 389 if (xmlTextReaderIsEmptyElement(reader) == 0) { 390 depth = xmlTextReaderDepth(reader);//track the depth. 391 status = xmlTextReaderAdvanceToNextStartOrEndElement(reader); 392 while (xmlTextReaderDepth(reader) > depth) { 393 if (status < 1) { 394 //panic: XML read error. 395 [NSException raise: @"XMLReadError" 396 format: @"Error handling a child element."]; 397 } 398 else if ([self readJAXBChildElement: reader]) { 399 status = xmlTextReaderAdvanceToNextStartOrEndElement(reader); 400 } 401 else { 402 status = [self readUnknownJAXBChildElement: reader]; 403 } 404 } 405 } 406 } 407 } 408 return self; 409} 410 411/** 412 * Write the XML type value of this object to the writer. 413 * 414 * @param writer The writer. 415 */ 416- (void) writeXMLType: (xmlTextWriterPtr) writer 417{ 418 [self writeJAXBAttributes: writer]; 419 [self writeJAXBValue: writer]; 420 [self writeJAXBChildElements: writer]; 421} 422 423/** 424 * Read the XML element from the reader; an instance of NSXMLElement. 425 * 426 * @param reader The reader. 427 * @return An instance of NSXMLElement 428 */ 429+ (id<JAXBElement>) readXMLElement: (xmlTextReaderPtr) reader 430{ 431 return (id<JAXBElement>) [JAXBBasicXMLNode readXMLType: reader]; 432} 433 434/** 435 * No op; root objects don't have an element name/namespace. Subclasses must override. 436 * 437 * @param writer The writer. 438 */ 439- (void) writeXMLElement: (xmlTextWriterPtr) writer 440{ 441 //no-op 442} 443 444/** 445 * No op; root objects don't have an element name/namespace. Subclasses must override. 446 * 447 * @param writer The writer. 448 * @param writeNs Ignored. 449 */ 450- (void) writeXMLElement: (xmlTextWriterPtr) writer writeNamespaces: (BOOL) writeNs 451{ 452 //no-op 453} 454 455/** 456 * No-op; base objects do not handle any attributes. 457 * 458 * @param reader The reader pointing to the attribute. 459 * @return NO 460 */ 461- (BOOL) readJAXBAttribute: (xmlTextReaderPtr) reader 462{ 463 return NO; 464} 465 466/** 467 * No-op; base objects do not handle any values. 468 * 469 * @param reader The reader pointing to the element containing a value. 470 * @return NO 471 */ 472- (BOOL) readJAXBValue: (xmlTextReaderPtr) reader 473{ 474 return NO; 475} 476 477/** 478 * No-op; base objects do not handle any child elements. 479 * 480 * @param reader The reader pointing to the child element. 481 * @return NO 482 */ 483- (BOOL) readJAXBChildElement: (xmlTextReaderPtr) reader 484{ 485 return NO; 486} 487 488/** 489 * No-op; base objects do not handle any attributes. 490 * 491 * @param reader The reader pointing to the unknown attribute. 492 */ 493- (void) readUnknownJAXBAttribute: (xmlTextReaderPtr) reader 494{ 495} 496 497/** 498 * Just skips the unknown element; base objects do not handle any child elements. 499 * 500 * @param reader The reader pointing to the unknown child element. 501 * @return The status of the reader after skipping the unknown child element. 502 */ 503- (int) readUnknownJAXBChildElement: (xmlTextReaderPtr) reader 504{ 505 return xmlTextReaderSkipElement(reader); 506} 507 508/** 509 * No-op; base objects have no attributes. 510 * 511 * @param writer The writer. 512 */ 513- (void) writeJAXBAttributes: (xmlTextWriterPtr) writer 514{ 515 //no-op. 516} 517 518/** 519 * No-op; base objects have no element value. 520 * 521 * @param writer The writer. 522 */ 523- (void) writeJAXBValue: (xmlTextWriterPtr) writer 524{ 525 //no-op. 526} 527 528/** 529 * No-op; base objects have no child elements. 530 * 531 * @param writer The writer. 532 */ 533- (void) writeJAXBChildElements: (xmlTextWriterPtr) writer 534{ 535 //no-op. 536} 537 538@end /*NSObject (JAXB)*/ 539 540/** 541 * Implementation of the JAXB type, element for an xml element. 542 */ 543@implementation JAXBBasicXMLNode 544 545/** 546 * Accessor for the (local) name of the XML node. 547 * 548 * @return The (local) name of the XML node. 549 */ 550- (NSString *) name 551{ 552 return _name; 553} 554 555/** 556 * Accessor for the (local) name of the XML node. 557 * 558 * @param newName The (local) name of the XML node. 559 */ 560- (void) setName: (NSString *) newName 561{ 562 [newName retain]; 563 [_name release]; 564 _name = newName; 565} 566 567/** 568 * Accessor for the namespace of the XML node. 569 * 570 * @return The namespace of the XML node. 571 */ 572- (NSString *) ns 573{ 574 return _ns; 575} 576 577/** 578 * Accessor for the namespace of the XML node. 579 * 580 * @param newNs The namespace of the XML node. 581 */ 582- (void) setNs: (NSString *) newNs 583{ 584 [newNs retain]; 585 [_ns release]; 586 _ns = newNs; 587} 588 589/** 590 * Accessor for the namespace prefix of the XML node. 591 * 592 * @return The namespace prefix of the XML node. 593 */ 594- (NSString *) prefix 595{ 596 return _prefix; 597} 598 599/** 600 * Accessor for the namespace prefix of the XML node. 601 * 602 * @param newPrefix The namespace prefix of the XML node. 603 */ 604- (void) setPrefix: (NSString *) newPrefix 605{ 606 [newPrefix retain]; 607 [_prefix release]; 608 _prefix = newPrefix; 609} 610 611/** 612 * Accessor for the value of the XML node. 613 * 614 * @return The value of the XML node. 615 */ 616- (NSString *) value 617{ 618 return _value; 619} 620 621/** 622 * Accessor for the value of the XML node. 623 * 624 * @param newValue The value of the XML node. 625 */ 626- (void) setValue: (NSString *) newValue 627{ 628 [newValue retain]; 629 [_value release]; 630 _value = newValue; 631} 632 633/** 634 * Accessor for the child elements of the XML node. 635 * 636 * @return The child elements of the XML node. 637 */ 638- (NSArray *) childElements 639{ 640 return _childElements; 641} 642 643/** 644 * Accessor for the child elements of the XML node. 645 * 646 * @param newValue The child elements of the XML node. 647 */ 648- (void) setChildElements: (NSArray *) newChildElements 649{ 650 [newChildElements retain]; 651 [_childElements release]; 652 _childElements = newChildElements; 653} 654 655/** 656 * Accessor for the attributes of the XML node. 657 * 658 * @return The attributes of the XML node. 659 */ 660- (NSArray *) attributes 661{ 662 return _attributes; 663} 664 665/** 666 * Accessor for the attributes of the XML node. 667 * 668 * @param newAttributes The attributes of the XML node. 669 */ 670- (void) setAttributes: (NSArray *) newAttributes 671{ 672 [newAttributes retain]; 673 [_attributes release]; 674 _attributes = newAttributes; 675} 676 677- (void) dealloc { 678 [self setName: nil]; 679 [self setNs: nil]; 680 [self setPrefix: nil]; 681 [self setValue: nil]; 682 [self setChildElements: nil]; 683 [self setAttributes: nil]; 684 [super dealloc]; 685} 686@end /*implementation JAXBBasicXMLNode*/ 687 688/** 689 * Internal, private interface for JAXB reading and writing. 690 */ 691@interface JAXBBasicXMLNode (JAXB) <JAXBType, JAXBElement> 692 693@end /*interface JAXBBasicXMLNode (JAXB)*/ 694 695@implementation JAXBBasicXMLNode (JAXB) 696 697/** 698 * Read the XML type from the reader; an instance of JAXBBasicXMLNode. 699 * 700 * @param reader The reader. 701 * @return An instance of JAXBBasicXMLNode 702 */ 703+ (id<JAXBType>) readXMLType: (xmlTextReaderPtr) reader 704{ 705 JAXBBasicXMLNode *node = [[JAXBBasicXMLNode alloc] init]; 706 NS_DURING 707 { 708 [node initWithReader: reader]; 709 } 710 NS_HANDLER 711 { 712 [node dealloc]; 713 node = nil; 714 [localException raise]; 715 } 716 NS_ENDHANDLER 717 718 [node autorelease]; 719 return node; 720} 721 722/** 723 * Read an XML type from an XML reader into an existing instance of JAXBBasicXMLNode. 724 * 725 * @param reader The reader. 726 * @param existing The existing instance into which to read values. 727 */ 728- (id) initWithReader: (xmlTextReaderPtr) reader 729{ 730 int status, depth; 731 JAXBBasicXMLNode *child; 732 xmlChar *value = NULL; 733 const xmlChar *text; 734 NSMutableArray *children; 735 736 if ((self = [self init])) { 737 depth = xmlTextReaderDepth(reader); 738 [self setName: [NSString stringWithUTF8String: (const char *) xmlTextReaderLocalName(reader)]]; 739 [self setNs: [NSString stringWithUTF8String: (const char *) xmlTextReaderNamespaceUri(reader)]]; 740 [self setPrefix: [NSString stringWithUTF8String: (const char *)xmlTextReaderPrefix(reader)]]; 741 742 if (xmlTextReaderHasAttributes(reader)) { 743 child = nil; 744 children = [[NSMutableArray alloc] init]; 745 while (xmlTextReaderMoveToNextAttribute(reader)) { 746 child = [[JAXBBasicXMLNode alloc] init]; 747 [child setName: [NSString stringWithUTF8String: (const char *) xmlTextReaderLocalName(reader)]]; 748 [child setNs: [NSString stringWithUTF8String: (const char *)xmlTextReaderNamespaceUri(reader)]]; 749 [child setPrefix: [NSString stringWithUTF8String: (const char *) xmlTextReaderPrefix(reader)]]; 750 [child setValue: [NSString stringWithUTF8String: (const char *) xmlTextReaderValue(reader)]]; 751 [children addObject: child]; 752 } 753 [self setAttributes: children]; 754 755 status = xmlTextReaderMoveToElement(reader); 756 if (status < 1) { 757 //panic: unable to return to the element node. 758 [NSException raise: @"XMLReadError" 759 format: @"Error moving to element from attributes."]; 760 } 761 } 762 763 if (xmlTextReaderIsEmptyElement(reader) == 0) { 764 children = [[NSMutableArray alloc] init]; 765 status = xmlTextReaderRead(reader); 766 while (status == 1 && xmlTextReaderDepth(reader) > depth) { 767 switch (xmlTextReaderNodeType(reader)) { 768 case XML_READER_TYPE_ELEMENT: 769 child = (JAXBBasicXMLNode *) [JAXBBasicXMLNode readXMLType: reader]; 770 [children addObject: child]; 771 break; 772 case XML_READER_TYPE_TEXT: 773 case XML_READER_TYPE_CDATA: 774 text = xmlTextReaderConstValue(reader); 775 value = xmlStrncat(value, text, xmlStrlen(text)); 776 break; 777 default: 778 //skip anything else. 779 break; 780 } 781 782 status = xmlTextReaderRead(reader); 783 } 784 785 if (status < 1) { 786 //panic: xml read error 787 [NSException raise: @"XMLReadError" 788 format: @"Error reading child elements."]; 789 } 790 791 if ([children count] > 0) { 792 [self setChildElements: children]; 793 } 794 795 if (value != NULL) { 796 [self setValue: [NSString stringWithUTF8String: (const char *) value]]; 797 } 798 799 } 800 } 801 802 return self; 803} 804 805/** 806 * Read the XML element from the reader; an instance of NSXMLElement. 807 * 808 * @param reader The reader. 809 * @return An instance of NSXMLElement 810 */ 811+ (id<JAXBElement>) readXMLElement: (xmlTextReaderPtr) reader 812{ 813 return (id<JAXBElement>) [JAXBBasicXMLNode readXMLType: reader]; 814} 815 816/** 817 * Write the basic node to an xml writer. 818 * 819 * @param writer The writer. 820 */ 821- (void) writeXMLType: (xmlTextWriterPtr) writer 822{ 823 int status; 824 NSEnumerator *enumerator; 825 JAXBBasicXMLNode *child; 826 xmlChar *childns, *childname, *childprefix, *childvalue; 827 828 status = xmlTextWriterStartElementNS(writer, _prefix ? BAD_CAST [_prefix UTF8String] : NULL, _name ? BAD_CAST [_name UTF8String] : NULL, _ns ? BAD_CAST [_ns UTF8String] : NULL); 829 if (status < 0) { 830 childns = BAD_CAST ""; 831 if (_ns) { 832 childns = BAD_CAST [_ns UTF8String]; 833 } 834 835 childname = BAD_CAST ""; 836 if (_name) { 837 childname = BAD_CAST [_name UTF8String]; 838 } 839 840 [NSException raise: @"XMLWriteError" 841 format: @"Error writing start element {%s}%s for JAXBBasicXMLNode.", childns, childname]; 842 } 843 844 if (_attributes) { 845 enumerator = [_attributes objectEnumerator]; 846 while ( (child = (JAXBBasicXMLNode *)[enumerator nextObject]) ) { 847 childns = NULL; 848 if ([child ns]) { 849 childns = BAD_CAST [[child ns] UTF8String]; 850 } 851 852 childprefix = NULL; 853 if ([child prefix]) { 854 childprefix = BAD_CAST [[child prefix] UTF8String]; 855 } 856 857 childname = NULL; 858 if ([child name]) { 859 childname = BAD_CAST [[child name] UTF8String]; 860 } 861 862 childvalue = NULL; 863 if ([child value]) { 864 childvalue = BAD_CAST [[child value] UTF8String]; 865 } 866 867 status = xmlTextWriterWriteAttributeNS(writer, childprefix, childname, childns, childvalue); 868 if (status < 0) { 869 [NSException raise: @"XMLWriteError" 870 format: @"Error writing attribute {%s}%s for JAXBBasicXMLNode.", childns, childname]; 871 } 872 } 873 } 874 875 if (_value) { 876 status = xmlTextWriterWriteString(writer, BAD_CAST [_value UTF8String]); 877 if (status < 0) { 878 [NSException raise: @"XMLWriteError" 879 format: @"Error writing value of JAXBBasicXMLNode."]; 880 } 881 } 882 883 if (_childElements) { 884 enumerator = [_childElements objectEnumerator]; 885 while ( (child = [enumerator nextObject]) ) { 886 [child writeXMLType: writer]; 887 } 888 } 889 890 status = xmlTextWriterEndElement(writer); 891 if (status < 0) { 892 childns = BAD_CAST ""; 893 if (_ns) { 894 childns = BAD_CAST [_ns UTF8String]; 895 } 896 897 childname = BAD_CAST ""; 898 if (_name) { 899 childname = BAD_CAST [_name UTF8String]; 900 } 901 902 [NSException raise: @"XMLWriteError" 903 format: @"Error writing end element {%s}%s for JAXBBasicXMLNode.", childns, childname]; 904 } 905} 906 907/** 908 * Writes this node to a writer. 909 * 910 * @param writer The writer. 911 */ 912- (void) writeXMLElement: (xmlTextWriterPtr) writer 913{ 914 [self writeXMLType: writer]; 915} 916 917/** 918 * Writes this node to a writer. 919 * 920 * @param writer The writer. 921 * @param writeNs Whether to write the namespaces for this element to the xml writer. 922 */ 923- (void) writeXMLElement: (xmlTextWriterPtr) writer writeNamespaces: (BOOL) writeNs 924{ 925 [self writeXMLType: writer]; 926} 927 928@end /* implementation JAXBBasicXMLNode (JAXB) */ 929 930/** 931 * Declaration of the JAXB type for a string. 932 */ 933@interface NSString (JAXBType) <JAXBType> 934@end 935 936/** 937 * Implementation of the JAXB type for a string. 938 */ 939@implementation NSString (JAXBType) 940 941/** 942 * Read the XML type from the reader. 943 * 944 * @param reader The reader. 945 * @return The NSString that was read from the reader. 946 */ 947+ (id<JAXBType>) readXMLType: (xmlTextReaderPtr) reader 948{ 949 return [NSString stringWithUTF8String: (const char *) xmlTextReaderReadEntireNodeValue(reader)]; 950} 951 952/** 953 * Read an XML type from an XML reader into an existing instance. 954 * 955 * @param reader The reader. 956 * @param existing The existing instance into which to read values. 957 */ 958- (id) initWithReader: (xmlTextReaderPtr) reader 959{ 960 [NSException raise: @"XMLReadError" 961 format: @"An existing string cannot be modified."]; 962 return nil; 963} 964 965/** 966 * Write the NSString to the writer. 967 * 968 * @param writer The writer. 969 */ 970- (void) writeXMLType: (xmlTextWriterPtr) writer 971{ 972 xmlTextWriterWriteString(writer, BAD_CAST [self UTF8String]); 973} 974 975@end /*NSString (JAXBType)*/ 976 977 978 979/** 980 * Declaration of the JAXB type for a big number. 981 */ 982@interface NSNumber (JAXBType) <JAXBType> 983@end 984 985/** 986 * Implementation of the JAXB type for a big number. 987 */ 988@implementation NSNumber (JAXBType) 989 990/** 991 * Read the XML type from the reader. 992 * 993 * @param reader The reader. 994 * @return The NSNumber that was read from the reader. 995 */ 996+ (id<JAXBType>) readXMLType: (xmlTextReaderPtr) reader 997{ 998 return [NSNumber numberWithLongLong: [[NSString stringWithUTF8String: (const char *) xmlTextReaderReadEntireNodeValue(reader)] longLongValue]]; 999} 1000 1001/** 1002 * Read an XML type from an XML reader into an existing instance. 1003 * 1004 * @param reader The reader. 1005 * @param existing The existing instance into which to read values. 1006 */ 1007- (id) initWithReader: (xmlTextReaderPtr) reader 1008{ 1009 [NSException raise: @"XMLReadError" 1010 format: @"An existing number cannot be modified."]; 1011 return nil; 1012} 1013 1014/** 1015 * Write the NSNumber to the writer. 1016 * 1017 * @param writer The writer. 1018 */ 1019- (void) writeXMLType: (xmlTextWriterPtr) writer 1020{ 1021 xmlTextWriterWriteString(writer, BAD_CAST [[self description] UTF8String]); 1022} 1023 1024@end /*NSNumber (JAXBType)*/ 1025 1026 1027 1028/** 1029 * Declaration of the JAXB type for a big number. 1030 */ 1031@interface NSDecimalNumber (JAXBType) <JAXBType> 1032@end 1033 1034/** 1035 * Implementation of the JAXB type for a big number. 1036 */ 1037@implementation NSDecimalNumber (JAXBType) 1038 1039/** 1040 * Read the XML type from the reader. 1041 * 1042 * @param reader The reader. 1043 * @return The NSDecimalNumber that was read from the reader. 1044 */ 1045+ (id<JAXBType>) readXMLType: (xmlTextReaderPtr) reader 1046{ 1047 return [NSDecimalNumber decimalNumberWithString: [NSString stringWithUTF8String: (const char *) xmlTextReaderReadEntireNodeValue(reader)]]; 1048} 1049 1050/** 1051 * Read an XML type from an XML reader into an existing instance. 1052 * 1053 * @param reader The reader. 1054 * @param existing The existing instance into which to read values. 1055 */ 1056- (id) initWithReader: (xmlTextReaderPtr) reader 1057{ 1058 [NSException raise: @"XMLReadError" 1059 format: @"An existing decimal number cannot be modified."]; 1060 return nil; 1061} 1062 1063/** 1064 * Write the NSDecimalNumber to the writer. 1065 * 1066 * @param writer The writer. 1067 */ 1068- (void) writeXMLType: (xmlTextWriterPtr) writer 1069{ 1070 xmlTextWriterWriteString(writer, BAD_CAST [[self description] UTF8String]); 1071} 1072 1073@end /*NSDecimalNumber (JAXBType)*/ 1074 1075 1076 1077/** 1078 * Declaration of the JAXB type for a url. 1079 */ 1080@interface NSURL (JAXBType) <JAXBType> 1081@end 1082 1083/** 1084 * Implementation of the JAXB type for a url. 1085 */ 1086@implementation NSURL (JAXBType) 1087 1088/** 1089 * Read the XML type from the reader. 1090 * 1091 * @param reader The reader. 1092 * @return The NSURL that was read from the reader. 1093 */ 1094+ (id<JAXBType>) readXMLType: (xmlTextReaderPtr) reader 1095{ 1096 return [NSURL URLWithString: [NSString stringWithUTF8String: (const char *) xmlTextReaderReadEntireNodeValue(reader)]]; 1097} 1098 1099/** 1100 * Read an XML type from an XML reader into an existing instance. 1101 * 1102 * @param reader The reader. 1103 * @param existing The existing instance into which to read values. 1104 */ 1105- (id) initWithReader: (xmlTextReaderPtr) reader 1106{ 1107 [NSException raise: @"XMLReadError" 1108 format: @"An existing url cannot be modified."]; 1109 return nil; 1110} 1111 1112/** 1113 * Write the NSURL to the writer. 1114 * 1115 * @param writer The writer. 1116 */ 1117- (void) writeXMLType: (xmlTextWriterPtr) writer 1118{ 1119 xmlTextWriterWriteString(writer, BAD_CAST [[self absoluteString] UTF8String]); 1120} 1121 1122@end /*NSURL (JAXBType)*/ 1123 1124 1125 1126/** 1127 * Declaration of the JAXB type for binary data. 1128 */ 1129@interface NSData (JAXBType) <JAXBType> 1130@end 1131 1132/** 1133 * Implementation of the JAXB type for a binary data. 1134 */ 1135@implementation NSData (JAXBType) 1136 1137/** 1138 * Read the XML type from the reader. 1139 * 1140 * @param reader The reader. 1141 * @return The NSData that was read from the reader. 1142 */ 1143+ (id<JAXBType>) readXMLType: (xmlTextReaderPtr) reader 1144{ 1145 xmlChar *base64data = xmlTextReaderReadEntireNodeValue(reader); 1146 int len; 1147 unsigned char *data = _decode_base64(base64data, &len); 1148 NSData *wrappedData = [NSData dataWithBytesNoCopy: data length: len]; 1149 free(base64data); 1150 return wrappedData; 1151} 1152 1153/** 1154 * Read an XML type from an XML reader into an existing instance. 1155 * 1156 * @param reader The reader. 1157 * @param existing The existing instance into which to read values. 1158 */ 1159- (id) initWithReader: (xmlTextReaderPtr) reader 1160{ 1161 [NSException raise: @"XMLReadError" 1162 format: @"An existing NSData cannot be modified."]; 1163 return nil; 1164} 1165 1166/** 1167 * Write the NSData to the writer. 1168 * 1169 * @param writer The writer. 1170 */ 1171- (void) writeXMLType: (xmlTextWriterPtr) writer 1172{ 1173 xmlChar *out = _encode_base64((unsigned char *)[self bytes], [self length]); 1174 xmlTextWriterWriteString(writer, out); 1175 free(out); 1176} 1177 1178@end /*NSData (JAXBType)*/ 1179 1180 1181 1182/** 1183 * Declaration of the JAXB type for a big number. 1184 */ 1185@interface NSDate (JAXBType) <JAXBType> 1186@end 1187 1188/** 1189 * Implementation of the JAXB type for a big number. 1190 */ 1191@implementation NSDate (JAXBType) 1192 1193/** 1194 * Read the XML type from the reader. 1195 * 1196 * @param reader The reader. 1197 * @return The NSDate that was read from the reader. 1198 */ 1199+ (id<JAXBType>) readXMLType: (xmlTextReaderPtr) reader 1200{ 1201 return [NSCalendarDate readXMLType: reader]; 1202} 1203 1204/** 1205 * Read an XML type from an XML reader into an existing instance. 1206 * 1207 * @param reader The reader. 1208 * @param existing The existing instance into which to read values. 1209 */ 1210- (id) initWithReader: (xmlTextReaderPtr) reader 1211{ 1212 [NSException raise: @"XMLReadError" 1213 format: @"An existing date cannot be modified."]; 1214 return nil; 1215} 1216 1217/** 1218 * Write the NSDate to the writer. 1219 * 1220 * @param writer The writer. 1221 */ 1222- (void) writeXMLType: (xmlTextWriterPtr) writer 1223{ 1224 NSDateFormatter *formatter = [[NSDateFormatter alloc] initWithDateFormat: @"%Y-%m-%dT%H:%M:%S %z" allowNaturalLanguage: NO]; 1225 xmlChar *timevalue = BAD_CAST [[formatter stringForObjectValue: self] UTF8String]; 1226 timevalue[19] = timevalue[20]; 1227 timevalue[20] = timevalue[21]; 1228 timevalue[21] = timevalue[22]; 1229 timevalue[22] = ':'; 1230 xmlTextWriterWriteString(writer, timevalue); 1231 [formatter release]; 1232} 1233@end /*NSDate (JAXBType)*/ 1234 1235 1236 1237/** 1238 * Declaration of the JAXB type for a big number. 1239 */ 1240@interface NSCalendarDate (JAXBType) <JAXBType> 1241@end 1242 1243/** 1244 * Implementation of the JAXB type for a big number. 1245 */ 1246@implementation NSCalendarDate (JAXBType) 1247 1248/** 1249 * Read the XML type from the reader. 1250 * 1251 * @param reader The reader. 1252 * @return The NSCalendarDate that was read from the reader. 1253 */ 1254+ (id<JAXBType>) readXMLType: (xmlTextReaderPtr) reader 1255{ 1256 xmlChar *timevalue = xmlTextReaderReadEntireNodeValue(reader); 1257 NSInteger year = 0; 1258 NSUInteger month = 1, day = 1, hour = 0, minute = 0, second = 0; 1259 NSTimeZone *tz = nil; 1260 BOOL skip_time = NO; 1261 int index = 0, token_index = 0, len = xmlStrlen(timevalue), offset_seconds = 0; 1262 char token[len]; 1263 1264 if (len > (index + 5) && timevalue[index + 4] == '-') { 1265 //assume we're at yyyy-MM-dd 1266 token_index = 0; 1267 while (index < len && timevalue[index] != '-') { 1268 token[token_index++] = timevalue[index++]; 1269 } 1270 token[token_index] = '\0'; 1271 if (token_index != 4) { 1272 [NSException raise: @"XMLReadError" 1273 format: @"Unable to read dateTime %s; invalid year: %s", timevalue, token]; 1274 } 1275 year = atoi(token); 1276 index++; 1277 1278 //go to next '-' character. 1279 token_index = 0; 1280 while (index < len && timevalue[index] != '-') { 1281 token[token_index++] = timevalue[index++]; 1282 } 1283 token[token_index] = '\0'; 1284 if (token_index != 2) { 1285 [NSException raise: @"XMLReadError" 1286 format: @"Unable to read dateTime %s; invalid month: %s", timevalue, token]; 1287 } 1288 month = atoi(token); 1289 index++; 1290 1291 //go to 'T', 'Z', '+', or '-' character. 1292 token_index = 0; 1293 while (index < len && timevalue[index] != 'T' && timevalue[index] != 'Z' && timevalue[index] != '-' && timevalue[index] != '+') { 1294 token[token_index++] = timevalue[index++]; 1295 } 1296 token[token_index] = '\0'; 1297 if (token_index != 2) { 1298 [NSException raise: @"XMLReadError" 1299 format: @"Unable to read dateTime %s; invalid day of month: %s", timevalue, token]; 1300 } 1301 day = atoi(token); 1302 if (timevalue[index] != 'T') { 1303 skip_time = YES; 1304 } 1305 if (timevalue[index] != '-') { 1306 index++; 1307 } 1308 } 1309 1310 if (skip_time == NO || (len > (index + 3) && timevalue[index + 2] == ':')) { 1311 //assume we're at HH:mm:ss 1312 1313 //go to ':' character. 1314 token_index = 0; 1315 while (index < len && timevalue[index] != ':') { 1316 token[token_index++] = timevalue[index++]; 1317 } 1318 token[token_index] = '\0'; 1319 if (token_index != 2) { 1320 [NSException raise: @"XMLReadError" 1321 format: @"Unable to read dateTime %s; invalid hour: %s", timevalue, token]; 1322 } 1323 hour = atoi(token); 1324 index++; 1325 1326 //go to ':' character. 1327 token_index = 0; 1328 while (index < len && timevalue[index] != ':') { 1329 token[token_index++] = timevalue[index++]; 1330 } 1331 token[token_index] = '\0'; 1332 if (token_index != 2) { 1333 [NSException raise: @"XMLReadError" 1334 format: @"Unable to read dateTime %s; invalid minute: %s", timevalue, token]; 1335 } 1336 minute = atoi(token); 1337 index++; 1338 1339 //go to '+' or '-' or 'Z' character. 1340 token_index = 0; 1341 while (index < len && timevalue[index] != '+' && timevalue[index] != '-' && timevalue[index] != 'Z') { 1342 token[token_index++] = timevalue[index++]; 1343 } 1344 token[token_index] = '\0'; 1345 if (token_index == 0) { 1346 [NSException raise: @"XMLReadError" 1347 format: @"Unable to read dateTime %s; invalid seconds: %s", timevalue, token]; 1348 } 1349 second = (NSUInteger) atof(token); 1350 if (timevalue[index] != '-') { 1351 index++; 1352 } 1353 } 1354 1355 //go to ':' character. 1356 token_index = 0; 1357 while (index < len && timevalue[index] != ':') { 1358 token[token_index++] = timevalue[index++]; 1359 } 1360 token[token_index] = '\0'; 1361 offset_seconds += atoi(token) * 60 * 60; 1362 index++; 1363 1364 //go to end. 1365 token_index = 0; 1366 while (index < len) { 1367 token[token_index++] = timevalue[index++]; 1368 } 1369 token[token_index] = '\0'; 1370 offset_seconds += atoi(token) * 60; 1371 1372 tz = [NSTimeZone timeZoneForSecondsFromGMT: offset_seconds]; 1373 free(timevalue); 1374 return [NSCalendarDate dateWithYear: year month: month day: day hour: hour minute: minute second: second timeZone: tz]; 1375} 1376 1377/** 1378 * Read an XML type from an XML reader into an existing instance. 1379 * 1380 * @param reader The reader. 1381 * @param existing The existing instance into which to read values. 1382 */ 1383- (id) initWithReader: (xmlTextReaderPtr) reader 1384{ 1385 [NSException raise: @"XMLReadError" 1386 format: @"An existing date cannot be modified."]; 1387 return nil; 1388} 1389 1390/** 1391 * Write the NSDate to the writer. 1392 * 1393 * @param writer The writer. 1394 */ 1395- (void) writeXMLType: (xmlTextWriterPtr) writer 1396{ 1397 [super writeXMLType: writer]; 1398} 1399 1400@end /*NSCalendarDate (JAXBType)*/ 1401#endif /* ENUNCIATE_OBJC_CLASSES */ 1402 1403#ifndef ENUNCIATE_XML_OBJC_PRIMITIVE_FUNCTIONS 1404#define ENUNCIATE_XML_OBJC_PRIMITIVE_FUNCTIONS 1405 1406/*******************boolean************************************/ 1407 1408/** 1409 * Read a boolean value from the reader. 1410 * 1411 * @param reader The reader (pointing at a node with a value). 1412 * @return YES if "true" was read. NO otherwise. 1413 */ 1414static BOOL *xmlTextReaderReadBooleanType(xmlTextReaderPtr reader) { 1415 xmlChar *nodeValue = xmlTextReaderReadEntireNodeValue(reader); 1416 BOOL *value = malloc(sizeof(BOOL)); 1417 *value = (xmlStrcmp(BAD_CAST "true", nodeValue) == 0) ? YES : NO; 1418 free(nodeValue); 1419 return value; 1420} 1421 1422/** 1423 * Write a boolean value to the writer. 1424 * 1425 * @param writer The writer. 1426 * @param value The value to be written. 1427 * @return the bytes written (may be 0 because of buffering) or -1 in case of error. 1428 */ 1429static int xmlTextWriterWriteBooleanType(xmlTextWriterPtr writer, BOOL *value) { 1430 if (*value) { 1431 return xmlTextWriterWriteString(writer, BAD_CAST "false"); 1432 } 1433 else { 1434 return xmlTextWriterWriteString(writer, BAD_CAST "true"); 1435 } 1436} 1437 1438/*******************byte************************************/ 1439 1440/** 1441 * Read a byte value from the reader. 1442 * 1443 * @param reader The reader (pointing at a node with a value). 1444 * @return the byte. 1445 */ 1446static unsigned char *xmlTextReaderReadByteType(xmlTextReaderPtr reader) { 1447 xmlChar *nodeValue = xmlTextReaderReadEntireNodeValue(reader); 1448 unsigned char *value = malloc(sizeof(unsigned char)); 1449 *value = (unsigned char) atoi((char *) nodeValue); 1450 free(nodeValue); 1451 return value; 1452} 1453 1454/** 1455 * Write a byte value to the writer. 1456 * 1457 * @param writer The writer. 1458 * @param value The value to be written. 1459 * @return the bytes written (may be 0 because of buffering) or -1 in case of error. 1460 */ 1461static int xmlTextWriterWriteByteType(xmlTextWriterPtr writer, unsigned char *value) { 1462 return xmlTextWriterWriteFormatString(writer, "%i", *value); 1463} 1464 1465/*******************double************************************/ 1466 1467/** 1468 * Read a double value from the reader. 1469 * 1470 * @param reader The reader (pointing at a node with a value). 1471 * @return the double. 1472 */ 1473static double *xmlTextReaderReadDoubleType(xmlTextReaderPtr reader) { 1474 xmlChar *nodeValue = xmlTextReaderReadEntireNodeValue(reader); 1475 double *value = malloc(sizeof(double)); 1476 *value = atof((char *) nodeValue); 1477 free(nodeValue); 1478 return value; 1479} 1480 1481/** 1482 * Write a double value to the writer. 1483 * 1484 * @param writer The writer. 1485 * @param value The value to be written. 1486 * @return the bytes written (may be 0 because of buffering) or -1 in case of error. 1487 */ 1488static int xmlTextWriterWriteDoubleType(xmlTextWriterPtr writer, double *value) { 1489 return xmlTextWriterWriteFormatString(writer, "%f", *value); 1490} 1491 1492/*******************float************************************/ 1493 1494/** 1495 * Read a float value from the reader. 1496 * 1497 * @param reader The reader (pointing at a node with a value). 1498 * @return the float. 1499 */ 1500static float *xmlTextReaderReadFloatType(xmlTextReaderPtr reader) { 1501 xmlChar *nodeValue = xmlTextReaderReadEntireNodeValue(reader); 1502 float *value = malloc(sizeof(float)); 1503 *value = atof((char *)nodeValue); 1504 free(nodeValue); 1505 return value; 1506} 1507 1508/** 1509 * Write a float value to the writer. 1510 * 1511 * @param writer The writer. 1512 * @param value The value to be written. 1513 * @return the bytes written (may be 0 because of buffering) or -1 in case of error. 1514 */ 1515static int xmlTextWriterWriteFloatType(xmlTextWriterPtr writer, float *value) { 1516 return xmlTextWriterWriteFormatString(writer, "%f", *value); 1517} 1518 1519/*******************int************************************/ 1520 1521/** 1522 * Read a int value from the reader. 1523 * 1524 * @param reader The reader (pointing at a node with a value). 1525 * @param value The value to be written. 1526 * @return the int. 1527 */ 1528static int *xmlTextReaderReadIntType(xmlTextReaderPtr reader) { 1529 xmlChar *nodeValue = xmlTextReaderReadEntireNodeValue(reader); 1530 int *value = malloc(sizeof(int)); 1531 *value = atoi((char *)nodeValue); 1532 free(nodeValue); 1533 return value; 1534} 1535 1536/** 1537 * Write a int value to the writer. 1538 * 1539 * @param writer The writer. 1540 * @param value The value to be written. 1541 * @return the bytes written (may be 0 because of buffering) or -1 in case of error. 1542 */ 1543static int xmlTextWriterWriteIntType(xmlTextWriterPtr writer, int *value) { 1544 return xmlTextWriterWriteFormatString(writer, "%i", *value); 1545} 1546 1547/*******************long************************************/ 1548 1549/** 1550 * Read a long value from the reader. 1551 * 1552 * @param reader The reader (pointing at a node with a value). 1553 * @return the long. 1554 */ 1555static long *xmlTextReaderReadLongType(xmlTextReaderPtr reader) { 1556 xmlChar *nodeValue = xmlTextReaderReadEntireNodeValue(reader); 1557 long *value = malloc(sizeof(long)); 1558 *value = atol((char *)nodeValue); 1559 free(nodeValue); 1560 return value; 1561} 1562 1563/** 1564 * Write a long value to the writer. 1565 * 1566 * @param writer The writer. 1567 * @param value The value to be written. 1568 * @return the bytes written (may be 0 because of buffering) or -1 in case of error. 1569 */ 1570static int xmlTextWriterWriteLongType(xmlTextWriterPtr writer, long *value) { 1571 return xmlTextWriterWriteFormatString(writer, "%ld", *value); 1572} 1573 1574/*******************short************************************/ 1575 1576/** 1577 * Read a short value from the reader. 1578 * 1579 * @param reader The reader (pointing at a node with a value). 1580 * @return the short. 1581 */ 1582static short *xmlTextReaderReadShortType(xmlTextReaderPtr reader) { 1583 xmlChar *nodeValue = xmlTextReaderReadEntireNodeValue(reader); 1584 short *value = malloc(sizeof(short)); 1585 *value = atoi((char *)nodeValue); 1586 free(nodeValue); 1587 return value; 1588} 1589 1590/** 1591 * Write a short value to the writer. 1592 * 1593 * @param writer The writer. 1594 * @param value The value to be written. 1595 * @return the bytes written (may be 0 because of buffering) or -1 in case of error. 1596 */ 1597static int xmlTextWriterWriteShortType(xmlTextWriterPtr writer, short *value) { 1598 return xmlTextWriterWriteFormatString(writer, "%h", *value); 1599} 1600 1601/*******************char************************************/ 1602 1603/** 1604 * Read a character value from the reader. 1605 * 1606 * @param reader The reader (pointing at a node with a value). 1607 * @return the character. 1608 */ 1609static xmlChar *xmlTextReaderReadCharacterType(xmlTextReaderPtr reader) { 1610 return xmlTextReaderReadEntireNodeValue(reader); 1611} 1612 1613/** 1614 * Write a character value to the writer. 1615 * 1616 * @param writer The writer. 1617 * @param value The value to be written. 1618 * @return the bytes written (may be 0 because of buffering) or -1 in case of error. 1619 */ 1620static int xmlTextWriterWriteCharacterType(xmlTextWriterPtr writer, xmlChar *value) { 1621 return xmlTextWriterWriteString(writer, value); 1622} 1623 1624#endif /* ENUNCIATE_XML_OBJC_PRIMITIVE_FUNCTIONS */ 1625 1626 1627/** 1628 * A collection of cards from the temple. 1629 1630 @author Duane Kuehne 1631 1632 */ 1633@implementation FSRESERVATIONV1Cards 1634 1635/** 1636 * The cards. 1637 */ 1638- (NSArray *) cardItems 1639{ 1640 return _cardItems; 1641} 1642 1643/** 1644 * The cards. 1645 */ 1646- (void) setCardItems: (NSArray *) newCardItems 1647{ 1648 [newCardItems retain]; 1649 [_cardItems release]; 1650 _cardItems = newCardItems; 1651} 1652 1653- (void) dealloc 1654{ 1655 [self setCardItems: nil]; 1656 [super dealloc]; 1657} 1658@end /* implementation FSRESERVATIONV1Cards */ 1659 1660/** 1661 * Internal, private interface for JAXB reading and writing. 1662 */ 1663@interface FSRESERVATIONV1Cards (JAXB) <JAXBReading, JAXBWriting, JAXBType> 1664 1665@end /*interface FSRESERVATIONV1Cards (JAXB)*/ 1666 1667/** 1668 * Internal, private implementation for JAXB reading and writing. 1669 */ 1670@implementation FSRESERVATIONV1Cards (JAXB) 1671 1672/** 1673 * Read an instance of FSRESERVATIONV1Cards from an XML reader. 1674 * 1675 * @param reader The reader. 1676 * @return An instance of FSRESERVATIONV1Cards defined by the XML reader. 1677 */ 1678+ (id<JAXBType>) readXMLType: (xmlTextReaderPtr) reader 1679{ 1680 FSRESERVATIONV1Cards *_fSRESERVATIONV1Cards = [[FSRESERVATIONV1Cards alloc] init]; 1681 NS_DURING 1682 { 1683 [_fSRESERVATIONV1Cards initWithReader: reader]; 1684 } 1685 NS_HANDLER 1686 { 1687 [_fSRESERVATIONV1Cards dealloc]; 1688 _fSRESERVATIONV1Cards = nil; 1689 [localException raise]; 1690 } 1691 NS_ENDHANDLER 1692 1693 [_fSRESERVATIONV1Cards autorelease]; 1694 return _fSRESERVATIONV1Cards; 1695} 1696 1697/** 1698 * Initialize this instance of FSRESERVATIONV1Cards according to 1699 * the XML being read from the reader. 1700 * 1701 * @param reader The reader. 1702 */ 1703- (id) initWithReader: (xmlTextReaderPtr) reader 1704{ 1705 return [super initWithReader: reader]; 1706} 1707 1708/** 1709 * Write the XML for this instance of FSRESERVATIONV1Cards to the writer. 1710 * Note that since we're only writing the XML type, 1711 * No start/end element will be written. 1712 * 1713 * @param reader The reader. 1714 */ 1715- (void) writeXMLType: (xmlTextWriterPtr) writer 1716{ 1717 [super writeXMLType:writer]; 1718} 1719 1720//documentation inherited. 1721- (BOOL) readJAXBAttribute: (xmlTextReaderPtr) reader 1722{ 1723 void *_child_accessor; 1724 1725 if ([super readJAXBAttribute: reader]) { 1726 return YES; 1727 } 1728 1729 return NO; 1730} 1731 1732//documentation inherited. 1733- (BOOL) readJAXBValue: (xmlTextReaderPtr) reader 1734{ 1735 return [super readJAXBValue: reader]; 1736} 1737 1738//documentation inherited. 1739- (BOOL) readJAXBChildElement: (xmlTextReaderPtr) reader 1740{ 1741 id __child; 1742 void *_child_accessor; 1743 int status, depth; 1744 1745 if ([super readJAXBChildElement: reader]) { 1746 return YES; 1747 } 1748 if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT 1749 && xmlStrcmp(BAD_CAST "card", xmlTextReaderConstLocalName(reader)) == 0 1750 && xmlStrcmp(BAD_CAST "http://api.familysearch.org/reservation/v1", xmlTextReaderConstNamespaceUri(reader)) == 0) { 1751 1752#if DEBUG_ENUNCIATE > 1 1753 NSLog(@"Attempting to read choice {http://api.familysearch.org/reservation/v1}card of type {http://api.familysearch.org/reservation/v1}card."); 1754#endif 1755 1756 __child = [FSRESERVATIONV1Card readXMLType: reader]; 1757#if DEBUG_ENUNCIATE > 1 1758 NSLog(@"successfully read choice {http://api.familysearch.org/reservation/v1}card of type {http://api.familysearch.org/reservation/v1}card."); 1759#endif 1760 1761 if ([self cardItems]) { 1762 [self setCardItems: [[self cardItems] arrayByAddingObject: __child]]; 1763 } 1764 else { 1765 [self setCardItems: [NSArray arrayWithObject: __child]]; 1766 } 1767 return YES; 1768 } //end "if choice" 1769 1770 1771 return NO; 1772} 1773 1774//documentation inherited. 1775- (int) readUnknownJAXBChildElement: (xmlTextReaderPtr) reader 1776{ 1777 return [super readUnknownJAXBChildElement: reader]; 1778} 1779 1780//documentation inherited. 1781- (void) readUnknownJAXBAttribute: (xmlTextReaderPtr) reader 1782{ 1783 [super readUnknownJAXBAttribute: reader]; 1784} 1785 1786//documentation inherited. 1787- (void) writeJAXBAttributes: (xmlTextWriterPtr) writer 1788{ 1789 int status; 1790 1791 [super writeJAXBAttributes: writer]; 1792 1793} 1794 1795//documentation inherited. 1796- (void) writeJAXBValue: (xmlTextWriterPtr) writer 1797{ 1798 [super writeJAXBValue: writer]; 1799} 1800 1801/** 1802 * Method for writing the child elements. 1803 * 1804 * @param writer The writer. 1805 */ 1806- (void) writeJAXBChildElements: (xmlTextWriterPtr) writer 1807{ 1808 int status; 1809 id __item; 1810 NSEnumerator *__enumerator; 1811 1812 [super writeJAXBChildElements: writer]; 1813 1814 if ([self cardItems]) { 1815 __enumerator = [[self cardItems] objectEnumerator]; 1816 1817 while ( (__item = [__enumerator nextObject]) ) { 1818 status = xmlTextWriterStartElementNS(writer, BAD_CAST "reservation_v1", BAD_CAST "card", NULL); 1819 if (status < 0) { 1820 [NSException raise: @"XMLWriteError" 1821 format: @"Error writing start child element {http://api.familysearch.org/reservation/v1}card."]; 1822 } 1823 1824#if DEBUG_ENUNCIATE > 1 1825 NSLog(@"writing element {http://api.familysearch.org/reservation/v1}card..."); 1826#endif 1827 [__item writeXMLType: writer]; 1828#if DEBUG_ENUNCIATE > 1 1829 NSLog(@"successfully wrote element {http://api.familysearch.org/reservation/v1}card..."); 1830#endif 1831 1832 status = xmlTextWriterEndElement(writer); 1833 if (status < 0) { 1834 [NSException raise: @"XMLWriteError" 1835 format: @"Error writing end child element {http://api.familysearch.org/reservation/v1}card."]; 1836 } 1837 } //end item iterator. 1838 } 1839} 1840@end /* implementation FSRESERVATIONV1Cards (JAXB) */ 1841 1842/** 1843 * A date. 1844 1845 @author Ryan Heaton 1846 1847 */ 1848@implementation FSRESERVATIONV1DateData 1849 1850/** 1851 * The date value. 1852 */ 1853- (NSString *) original 1854{ 1855 return _original; 1856} 1857 1858/** 1859 * The date value. 1860 */ 1861- (void) setOriginal: (NSString *) newOriginal 1862{ 1863 [newOriginal retain]; 1864 [_original release]; 1865 _original = newOriginal; 1866} 1867 1868/** 1869 * The normalized value. 1870 */ 1871- (NSString *) normalized 1872{ 1873 return _normalized; 1874} 1875 1876/** 1877 * The normalized value. 1878 */ 1879- (void) setNormalized: (NSString *) newNormalized 1880{ 1881 [newNormalized retain]; 1882 [_normalized release]; 1883 _normalized = newNormalized; 1884} 1885 1886/** 1887 * The astro date. 1888 */ 1889- (FSRESERVATIONV1DateAstro *) astro 1890{ 1891 return _astro; 1892} 1893 1894/** 1895 * The astro date. 1896 */ 1897- (void) setAstro: (FSRESERVATIONV1DateAstro *) newAstro 1898{ 1899 [newAstro retain]; 1900 [_astro release]; 1901 _astro = newAstro; 1902} 1903 1904- (void) dealloc 1905{ 1906 [self setOriginal: nil]; 1907 [self setNormalized: nil]; 1908 [self setAstro: nil]; 1909 [super dealloc]; 1910} 1911@end /* implementation FSRESERVATIONV1DateData */ 1912 1913/** 1914 * Internal, private interface for JAXB reading and writing. 1915 */ 1916@interface FSRESERVATIONV1DateData (JAXB) <JAXBReading, JAXBWriting, JAXBType> 1917 1918@end /*interface FSRESERVATIONV1DateData (JAXB)*/ 1919 1920/** 1921 * Internal, private implementation for JAXB reading and writing. 1922 */ 1923@implementation FSRESERVATIONV1DateData (JAXB) 1924 1925/** 1926 * Read an instance of FSRESERVATIONV1DateData from an XML reader. 1927 * 1928 * @param reader The reader. 1929 * @return An instance of FSRESERVATIONV1DateData defined by the XML reader. 1930 */ 1931+ (id<JAXBType>) readXMLType: (xmlTextReaderPtr) reader 1932{ 1933 FSRESERVATIONV1DateData *_fSRESERVATIONV1DateData = [[FSRESERVATIONV1DateData alloc] init]; 1934 NS_DURING 1935 { 1936 [_fSRESERVATIONV1DateData initWithReader: reader]; 1937 } 1938 NS_HANDLER 1939 { 1940 [_fSRESERVATIONV1DateData dealloc]; 1941 _fSRESERVATIONV1DateData = nil; 1942 [localException raise]; 1943 } 1944 NS_ENDHANDLER 1945 1946 [_fSRESERVATIONV1DateData autorelease]; 1947 return _fSRESERVATIONV1DateData; 1948} 1949 1950/** 1951 * Initialize this instance of FSRESERVATIONV1DateData according to 1952 * the XML being read from the reader. 1953 * 1954 * @param reader The reader. 1955 */ 1956- (id) initWithReader: (xmlTextReaderPtr) reader 1957{ 1958 return [super initWithReader: reader]; 1959} 1960 1961/** 1962 * Write the XML for this instance of FSRESERVATIONV1DateData to the writer. 1963 * Note that since we're only writing the XML type, 1964 * No start/end element will be written. 1965 * 1966 * @param reader The reader. 1967 */ 1968- (void) writeXMLType: (xmlTextWriterPtr) writer 1969{ 1970 [super writeXMLType:writer]; 1971} 1972 1973//documentation inherited. 1974- (BOOL) readJAXBAttribute: (xmlTextReaderPtr) reader 1975{ 1976 void *_child_accessor; 1977 1978 if ([super readJA…
Large files files are truncated, but you can click here to view the full file