Create a new SAX handler.

Handle an attribute that has been read by the parser.

An attribute definition has been parsed.

Called when a cdata block has been parsed.

Receiving some chars from the parser.

A comment has been parsed.

An element definition has been parsed.

Called when the document end has been detected.

Called when a closing tag has been processed.

Called when a closing tag has been processed.

An entity definition has been parsed.

Called when an error message needs to be output.

Called when an error message needs to be output.

Called to find out whether there is an external subset.

Called when a fatal error message needs to be output.

Called when a fatal error message needs to be output.

get an entity by name

get a parameter entity by name

An old global namespace has been parsed.

Called to find out whether there is an external subset.

Called to find out whether there is an internal subset.

Receiving some ignorable whitespaces from the parser.

Called to find out whether there is an internal subset.

Called to detemrine if the document is standalone.

Returns a pointer to the raw libxml data used by this document.
Only for use by libxml experts!

Called to return the filename from which an entity should be loaded.

An old global namespace has been parsed.

What to do when a notation declaration has been parsed.

Return the parser object with which this handler is associated. This may occasionally be useful.

A processing instruction has been parsed.

Called when an entity reference is detected.

Called when the document starts being processed.

Called when an opening tag has been processed.

Description forthcoming.

What to do when an unparsed entity declaration is parsed.

Called when a warning message needs to be output.

Called when a warning message needs to be output.

Returns the string value of the attribute.

Create a new document with the specified version.

 id d = [GSXMLDocument documentWithVersion: @"1.0"];

 [d setRoot: [d makeNodeWithNamespace: nil name: @"plist" content: nil]];
 [[d root] setObject: @"0.9" forKey: @"version"];
 n1 = [[d root] makeChildWithNamespace: nil name: @"dict" content: nil];
 [n1 makeComment: @" this is a comment "];
 [n1 makePI: @"pi1" content: @"this is a process instruction"];
 [n1 makeChildWithNamespace: nil name: @"key" content: @"Year Of Birth"];
 [n1 makeChildWithNamespace: nil name: @"integer" content: @"65"];
 [n1 makeChildWithNamespace: nil name: @"key" content: @"Pets Names"];
 

Returns a string representation of the document (ie the XML) or nil if the document does not have reasonable contents.

Returns the name of the encoding for this document.

Returns a pointer to the raw libxml data used by this document.
Only for use by libxml experts!

Creates a new node within the document.

 GSXMLNode *n1, *n2;
 GSXMLDocument *d;

 d = [GSXMLDocument documentWithVersion: @"1.0"];
 [d setRoot: [d makeNodeWithNamespace: nil name: @"plist" content: nil]];
 [[d root] setObject: @"0.9" forKey: @"version"];
 n1 = [[d root] makeChildWithNamespace: nil name: @"dict" content: nil];
 

Returns the root node of the document.

Sets the root of the document.
NB. The node must have been created as part of the receiving document (eg. using the -makeNodeWithNamespace:name:content: method).

Returns the version string for this document.

Uses the -description method to produce a string representation of the document and writes that to filename.

Uses the -description method to produce a string representation of the document and writes that to url.

Return the string representation of the specified numeric type.

Return the numeric constant value for the namespace type named. This method is inefficient, so the returned value should be saved for re-use later. The possible values are -

• XML_LOCAL_NAMESPACE

Returns the namespace reference

Returns a pointer to the raw libxml data used by this document.
Only for use by libxml experts!

return the next namespace.

Return the namespace prefix.

Return type of namespace

Return string representation of the type of the namespace.

Return the string constant value for the node type given.

Converts a node type string to a numeric constant which can be compared with the result of the -type method to determine what sort of node an instance is. Because this method is quite inefficient, you should cache the numeric type returned and re-use the cached value.

The node type names are -

• XML_ELEMENT_NODE
• XML_ATTRIBUTE_NODE
• XML_TEXT_NODE
• XML_CDATA_SECTION_NODE
• XML_ENTITY_REF_NODE
• XML_ENTITY_NODE
• XML_PI_NODE
• XML_COMMENT_NODE
• XML_DOCUMENT_NODE
• XML_DOCUMENT_TYPE_NODE
• XML_DOCUMENT_FRAG_NODE
• XML_NOTATION_NODE
• XML_HTML_DOCUMENT_NODE
• XML_DTD_NODE
• XML_ELEMENT_DECL
• XML_ATTRIBUTE_DECL
• XML_ENTITY_DECL

Return attributes and values as a dictionary

Return node content as a string. This should return meaningful information for text nodes and for entity nodes containing only text nodes.
If entity substitution was not enabled during parsing, an element containing text may actually contain both text nodes and entity reference nodes, in this case you should not use this method to get the content of the element, but should examine the child nodes of the element individually and perform any entity reference you need to do explicitly.
NB. There are five standard entities which are automatically substituted into the content text rather than appearing as entity nodes in their own right. These are '<', '>', ''', '"' and '&'. If you with to receive content in which these characters are represented by the original entity escapes, you need to use the -escapedContent method.

Returns a string representation of the node and all its children (ie the XML text) or nil if the node does not have reasonable contents.

Return the document in which this node exists.

This performs the same function as the -content method, but retains escaped character information (the standard five entities &lt;, &gt;, &apos;, &quot;, and &amp;) which are normally replaced with their standard equivalents (<, >, ', ", and &).

Return the first attribute in this node.

Return the first child node of this node.

    - (GSXMLNode*) elementRecursive: (GSXMLNode*)node
    {
      while (node != nil)
        {
          if ([node type] == XML_ELEMENT_NODE)
            {
              return node;
            }
          if ([node firstChild] != nil)
            {
              node = [self elementRecursive: [node firstChild]];
            }
          else
            {
              node = [node next];
            }
        }
      return node;
    }
  

Return the first child element of this node. If you wish to step through all children of the node (including non-element nodes) you should use the -firstChild method instead.

Convenience method, equivalent to calling -type and comparing it with the result of passing "XML_ELEMENT_NODE" to +typeFromDescription: (but faster).

Convenience method, equivalent to calling -type and comparing it with the result of passing "XML_TEXT_NODE" to +typeFromDescription: (but faster).

Returns a pointer to the raw libxml data used by this document.
Only for use by libxml experts!

Create and return an attribute (unless the named attribute already exists, in which case we update them value of the existing attribute and return it.

Creation of a new child element, added at the end of parent children list. ns and content parameters are optional (may be nil). If content is non nil, a child list containing the TEXTs and ENTITY_REFs node will be created. Return previous node.

 GSXMLNode *n1, *n2;
 GSXMLDocument *d, *d1;

 d = [GSXMLDocument documentWithVersion: @"1.0"];
 [d setRoot: [d makeNodeWithNamespace: nil
                                 name: @"plist"
                              content: nil]];
 [[d root] setObject: @"0.9" forKey: @"version"];
 n1 = [[d root] makeChildWithNamespace: nil
                                  name: @"dict"
                               content: nil];
 [n1 makeChildWithNamespace: nil name: @"key" content: @"Year Of Birth"];
 [n1 makeChildWithNamespace: nil name: @"integer" content: @"65"];

 [n1 makeChildWithNamespace: nil name: @"key" content: @"Pets Names"];
 [n1 makeChildWithNamespace: nil name: @"array" content: nil];

 

Creation of a new comment element, added at the end of parent children list.

 d = [GSXMLDocument documentWithVersion: @"1.0"];

 [d setRoot: [d makeNodeWithNamespace: nil name: @"plist" content: nil]];
 [[d root] setObject: @"0.9" forKey: @"version"];
 n1 = [[d root] makeChildWithNamespace: nil name: @"dict" content: nil];
 [n1 makeComment: @" this is a comment "];
 

Create a namespace attached to this node.

Creation of a new process instruction element, added at the end of parent children list.

 d = [GSXMLDocument documentWithVersion: @"1.0"];

 [d setRoot: [d makeNodeWithNamespace: nil name: @"plist" content: nil]];
 [[d root] setObject: @"0.9" forKey: @"version"];
 n1 = [[d root] makeChildWithNamespace: nil name: @"dict" content: nil];
 [n1 makeComment: @" this is a comment "];
 [n1 makePI: @"pi1" content: @"this is a process instruction"];
 

Creation of a new text element, added at the end of parent children list.

 d = [GSXMLDocument documentWithVersion: @"1.0"];

 [d setRoot: [d makeNodeWithNamespace: nil name: @"plist" content: nil]];
 [[d root] setObject: @"0.9" forKey: @"version"];
 n1 = [[d root] makeChildWithNamespace: nil name: @"dict" content: nil];
 [n1 makeText: @" this is a text "];
 

Return the node-name

Return the namespace of the node.

Return namespace definitions for the node

Return the next node at this level. This method can return any type of node, and it may be more convenient to use the -nextElement node if you are parsing a document where you wish to ignore non-element nodes such as whitespace text separating elements.

Returns the next element node, skipping past any other node types (such as text nodes). If there is no element node to be returned, this method returns nil.
NB. This method is not available in java, as the method name conflicts with that of java's Enumerator class.

Return the attribute value for the specified key.

Return the parent of this node.

Return the previous node at this level.

Return the previous element node at this level.
NB. This method is not available in java, as the method name conflicts with that of java's Enumerator class.

Return attributes and values as a dictionary, but applies the specified selector to each key before adding the key and value to the dictionary. The selector must be a method of NSString taking no arguments and returning an object suitable for use as a dictionary key.

This method exists for the use of GSWeb... it is probably not of much use elsewhere.

Sets the namespace of the receiver to the value specified.
Supplying a nil namespace removes any namespace previously set or any namespace that the node inherited from a parent when it was created.

Set (or reset) an attribute carried by a node.

   [n1 setObject: @"prop1" forKey: @"name1"];
   [n1 setObject: @"prop2" forKey: @"name2"];
   [n1 setObject: @"prop3" forKey: @"name3"];
 

Return node-type. The most efficient way of testing node types is to use this method and compare the return value with a value you previously obtained using the +typeFromDescription: method.

Return node type as a string.

This method controls the loading of external entities into the system. If it returns an empty string, the entity is not loaded. If it returns a filename, the entity is loaded from that file. If it returns nil, the default entity loading mechanism is used.

The default entity loading mechanism is to construct a file name from the locationURL, by replacing all path separators with underscores, then attempt to locate that file in the DTDs resource directory of the main bundle, and all the standard system locations.

As a special case, the default loader examines the publicID and if it is a GNUstep DTD, the loader constructs a special name from the ID (by replacing dots with underscores and spaces with hyphens) and looks for a file with that name and a '.dtd' extension in the GNUstep bundles.

NB. This method will only be called if there is no SAX handler in use, or if the corresponding method in the SAX handler returns nil.

Creation of a new Parser (for incremental parsing) by calling -initWithSAXHandler:

Creation of a new Parser by calling -initWithSAXHandler:withContentsOfFile:

 GSXMLParser       *p = [GSXMLParser parserWithContentsOfFile: @"macos.xml"];

 if ([p parse])
   {
     [[p document] dump];
   }
 else
   {
     printf("error parse file\n");
   }
 

Creation of a new Parser by calling -initWithSAXHandler:withContentsOfURL:

Creation of a new Parser by calling -initWithSAXHandler:withData:

Creation of a new Parser by calling -initWithSAXHandler:

If the handler object supplied is nil, the parser will build a tree representing the parsed file rather than attempting to get the handler to deal with the parsed elements and entities.

Creation of a new Parser by calling -initWithSAXHandler:withContentsOfFile:

 NSAutoreleasePool *arp = [NSAutoreleasePool new];
 GSSAXHandler *h = [GSDebugSAXHandler handler];
 GSXMLParser  *p = [GSXMLParser parserWithSAXHandler: h
                                  withContentsOfFile: @"macos.xml"];
 if ([p parse])
   {
      printf("ok\n");
   }
 RELEASE(arp);
 

Creation of a new Parser by calling -initWithSAXHandler:withContentsOfURL:

Creation of a new Parser by calling -initWithSAXHandler:withData:

Sets a directory in which to look for DTDs when resolving external references. Can be used whjen DTDs have not been installed in the normal locatioons.

Return the name of the string encoding (for XML) to use for the specified OpenStep encoding.

If called by a SAX callback routine, this method will terminate the parsiong process.

If executed during a parse operation, returns the current column number.

Sets whether the document needs to be validated.

Return the document produced as a result of parsing data.

Return error code for last parse operation.

Sets whether warnings are generated.

Initialisation of a new Parser with SAX handler.

If the handler object supplied is nil, the parser will use an instance of GSTreeSAXHandler to build a tree representing the parsed file. This tree will then be available (via the -document method) as a GSXMLDocument on completion of parsing.

The source for the parsing process is not specified - so parsing must be done incrementally by feeding data to the parser.

Initialisation of a new Parser with SAX handler (if not nil) by calling -initWithSAXHandler:

Sets the input source for the parser to be the specified file - so parsing of the entire file will be performed rather than incremental parsing.

Initialisation of a new Parser with SAX handler (if not nil) by calling -initWithSAXHandler:

Sets the input source for the parser to be the specified URL - so parsing of the entire document will be performed rather than incremental parsing.

Initialisation of a new Parser with SAX handler (if not nil) by calling -initWithSAXHandler:

Sets the input source for the parser to be the specified data object (which must contain an XML document), so parsing of the entire document will be performed rather than incremental parsing.

Initialisation of a new Parser with SAX handler (if not nil) by calling -initWithSAXHandler:

Sets the input source for the parser to be the specified input stream, so parsing of the entire document will be performed rather than incremental parsing.

Set and return the previous value for blank text nodes support. ignorableWhitespace nodes are only generated when running the parser in validating mode and when the current element doesn't allow CDATA or mixed content.

If executed during a parse operation, returns the current line number.

Returns the string into which warning and error messages are saved, or nil if they are being written to stderr.

Parse source. Return YES if parsed as valid, otherwise NO. If validation against a DTD is not enabled, the return value simply indicates whether the xml was well formed.
This method should be called once to parse the entire document.

 GSXMLParser       *p = [GSXMLParser parserWithContentsOfFile:@"macos.xml"];

 if ([p parse])
   {
     [[p doc] dump];
   }
 else
   {
     printf("error parse file\n");
   }
 

Pass data to the parser for incremental parsing. This method should be called many times, with each call passing another block of data from the same document. After the whole of the document has been parsed, the method should be called with an empty or nil data object to indicate end of parsing. On this final call, the return value indicates whether the document was valid or not. If validation to a DTD is not enabled, the return value simply indicates whether the xml was well formed.

 GSXMLParser       *p = [GSXMLParser parserWithSAXHandler: nil source: nil];

 while ((data = getMoreData()) != nil)
   {
     if ([p parse: data] == NO)
       {
         NSLog(@"parse error");
       }
   }
   // Do something with document parsed
 [p parse: nil];  // Completed parsing of document.
 

Return the public ID of the document being parsed.

Description forthcoming.

Sets up (or removes) a mutable string to which error and warning messages are saved. Using an argument of NO will cause these messages to be written to stderr (the default).
NB. A SAX handler which overrides the error and warning logging messages may stop this mechanism operating.

Set and return the previous value for entity support. Initially the parser always keeps entity references instead of substituting entity values in the output.

Return the system ID of the document being parsed.

Allows GSXMLRPC to act as a client of NSURLHandle. Internal use only.

Allows GSXMLRPC to act as a client of NSURLHandle. Internal use only.

Allows GSXMLRPC to act as a client of NSURLHandle. Internal use only.

Allows GSXMLRPC to act as a client of NSURLHandle. Internal use only.

Allows GSXMLRPC to act as a client of NSURLHandle. Internal use only.

Given a method name and an array of parameters, this method constructs the XML document for the corresponding XMLRPC call and returns the document as an NSData object containing UTF-8 text.
The params array may be empty or nil if there are no parameters to be passed.
The method returns nil if passed an invalid method name (a method name may contain any of the ascii alphanumeric characters and underscore, fullstop, colon, or slash).
This method is used internally when sending an XMLRPC method call to a remote system, but you can also call it yourself.

Given a method name and an array of parameters, this method constructs the XML document for the corresponding XMLRPC call and returns the document as a string.
The params array may be empty or nil if there are no parameters to be passed.
The method returns nil if passed an invalid method name (a method name may contain any of the ascii alphanumeric characters and underscore, fullstop, colon, or slash).

Constructs an XML document for an XMLRPC fault response with the specified code and string. The resulting document is returned as a string.
This method is intended for use by applications acting as XMLRPC servers.

Builds an XMLRPC response with the specified array of parameters and returns the document as a string.
The params array may be empty or nil if there are no parameters to be returned (an empty params element will be created).
This method is intended for use by applications acting as XMLRPC servers.

Return the value set by a prior call to -setCompact: (or NO... the default).

Returns the delegate previously set by the -setDelegate: method.
The delegate handles completion of asynchronous method calls to the URL specified when the receiver was initialised (if any).

Initialise the receiver to make XMLRPC calls to the specified URL.
This method just calls -initWithURL:certificate:privateKey:password: with nil arguments for the SSL credentials.

Initialise the receiver to make XMLRPC calls to the specified url and (optionally) with the specified SSL parameters.
The url argument may be nil, in which case the receiver will be unable to make XMLRPC calls, but can be used to parse incoming requests and build responses.
If the SSL credentials are non-nil, connections to the remote server will be authenticated using the supplied certificate so that the remote system knows who is contacting it.

Calls -sendMethodCall:params:timeout: and waits for the response.
Returns the response parameters (an array), the response fault (a dictionary), or a failure reason (a string).

Parses XML data containing an XMLRPC method call.
Returns the name of the method call.
Empties, and then places the method parameters (if any) in the params argument.
NB. Any containers (arrays or dictionaries) in the parsed parameters will be mutable, so you can modify this data structure as you like.
Raises an exception if parsing fails.
This method is intended for the use of XMLRPC server applications.

Parses XML data containing an XMLRPC method response.
Returns nil for success, the fault dictionary on failure.
Places the response parameters (if any) in the params argument.
NB. Any containers (arrays or dictionaries) in the parsed parameters will be mutable, so you can modify this data structure as you like.
Raises an exception if parsing fails.
Used internally when making a method call to a remote server.

Returns the result of the last method call, or nil if there has been no method call or one is in progress.
The result may be one of -

• A mutable array... the parameters of a success response.
• A dictionary... containing a fault response.
• A string... describing a low-level failure (eg. timeout).

NB. Any containers (arrays or dictionaries) in the parsed parameters of a success response will be mutable, so you can modify this data structure as you like.

Send an asynchronous XMLRPC method call with the specified timeout.
A delegate should have been set to handle the result of this call, but if one was not set the state of the asynchronous call may be polled by calling the -result method, which will return nil as long as the call has not completed.
The call may be cancelled by calling the -timeout: method
This method returns YES if the call was started, NO if it could not be started (eg because another call is in progress or because of bad arguments).
NB. For the asynchronous operation to proceed, the current NSRunLoop must be run.

Specify whether to generate compact XML (omit indentation and other white space and omit <string> element markup).
Compact representation saves some space (can be important when sent over slow/low bandwidth connections), but sacrifices readability.

Specify whether to perform debug trace on I/O
Return the previous value

Sets the delegate object which will receive callbacks when an XMLRPC call completes.
NB. this delegate is not retained, and should be removed before it is deallocated (call -setDelegate: again with a nil argument to remove the delegate).

Sets the time zone for use when sending/receiving date/time values.
The XMLRPC specification says that timezone is server dependent so you will need to set it according to the server you are connecting to.
If this is not set, UCT is assumed.

Return the time zone currently set.

Handles timeouts, passing information to delegate ... you don't need to call this method, but you may call it in order to cancel an asynchronous request as if it had timed out.

Returns the the value of the receiver... YES/NO, true/false.

Evaluates the supplied expression and returns the resulting node or node set. If the expression is invalid, returns nil.

Initialises the receiver as an xpath parser for the supplied document.

Description forthcoming.

Returns the number of nodes in the receiver.

Deprecated

Please note that index starts from 0.
Returns the node from the receiver at the specified index, or nil if no such node exists.

Returns the floating point (double ) value of the receiver.

Returns the string value of the receiver.

Performs an XSLT transformation on the specified file using the stylesheet provided.
Returns an autoreleased GSXMLDocument containing the transformed XML, or nil on failure.

Performs an XSLT transformation on the specified file using the stylesheet and parameters provided. See the libxslt documentation for details of the supported parameters.
Returns an autoreleased GSXMLDocument containing the transformed XML, or nil on failure.

Performs an XSLT transformation on the specified file using the stylesheet provided.
Returns an autoreleased GSXMLDocument containing the transformed XML, or nil on failure.

Performs an XSLT transformation on the specified file using the stylesheet and parameters provided.See the libxslt documentation for details of the supported parameters.
Returns an autoreleased GSXMLDocument containing the transformed XML, or nil on failure.

Performs an XSLT transformation on the current document using the supplied stylesheet.
Returns an autoreleased GSXMLDocument containing the transformed XML, or nil on failure.

Performs an XSLT transformation on the current document using the supplied stylesheet and paramaters (params may be nil). See the libxslt documentation for details of the supported parameters.
Returns an autoreleased GSXMLDocument containing the transformed XML, or nil on failure.

Called by the sender when an XMLRPC method call completes (either success or failure). The delegate may then call the -result method to retrieve the result of the method call from the sender.

Deals with standard XML internal entities.
Converts the five XML special characters in the receiver ('>', '<', '&', ''' and '"') to their escaped equivalents, and return the escaped string.
Also converts non-ascii characters to the corresponding numeric entity escape sequences.
You should perform any non-standard entity substitution you require after you have called this method.

Deals with standard XML internal entities.
Converts the five XML escape sequences ('&gt;', '&lt;', '&amp;', '&apos;' and '&quot;') to the unicode characters they represent, and returns the unescaped string.
Also converts numeric entity escape sequences to the corresponding unicode characters.
You should perform any non-standard entity substitution you require before you have called this method.