| Table of Content: General overviewThe basic buffer typeInput I/O handlersOutput I/O handlersThe entities loaderExample of customized I/O
 The module xmlIO.hprovidestheinterfaces
to the libxml2 I/O system. This consists of 4 main parts: The general mechanism used when loading
http://rpmfind.net/xml.htmlforexample in the HTML parser is the following: The default entity loader
    callsxmlNewInputFromFile()withthe parsing context and the
    URIstring.the URI string is checked against the existing registered
    handlersusingtheir match() callback function, if the HTTP module was
    compiledin, it isregistered and its match() function will succeedsthe open() function of the handler is called and if
    successfulwillreturn an I/O Input bufferthe parser will the start reading from this buffer
    andprogressivelyfetch information from the resource, calling the
    read()function of thehandler until the resource is exhaustedif an encoding change is detected it will be installed on
    theinputbuffer, providing buffering and efficient use of
    theconversionroutinesonce the parser has finished, the close() function of the
    handleriscalled once and the Input buffer and associated
    resourcesaredeallocated.
 The user defined callbacks are checked first to allow overriding
ofthedefault libxml2 I/O routines. All the buffer manipulation handling is done
usingthexmlBuffertype define intree.hwhich
isaresizable memory buffer. The buffer allocation strategy can be selected
tobeeither best-fit or use an exponential doubling one (CPU vs.
memoryusetrade-off). The values
areXML_BUFFER_ALLOC_EXACTandXML_BUFFER_ALLOC_DOUBLEIT,and
can be set individually or on asystem wide basis
usingxmlBufferSetAllocationScheme(). A numberof functions allows
tomanipulate buffers with names starting
withthexmlBuffer...prefix. An Input I/O handler is a
simplestructurexmlParserInputBuffercontaining a context
associated totheresource (file descriptor, or pointer to a protocol handler),
the read()andclose() callbacks to use and an xmlBuffer. And extra xmlBuffer
and acharsetencoding handler are also present to support charset
conversionwhenneeded. An Output handler xmlOutputBufferis completely similar
toanInput one except the callbacks are write() and close(). The entity loader resolves requests for new entities and create
inputsforthe parser. Creating an input from a filename or an URI string
isdonethrough the xmlNewInputFromFile() routine.  The default entity loader
donothandle the PUBLIC identifier associated with an entity (if any). So
itjustcalls xmlNewInputFromFile() with the SYSTEM identifier (which
ismandatory inXML). If you want to hook up a catalog mechanism then you simply need
tooverridethe default entity loader, here is an example: #include <libxml/xmlIO.h>
xmlExternalEntityLoader defaultLoader = NULL;
xmlParserInputPtr
xmlMyExternalEntityLoader(const char *URL, const char *ID,
                               xmlParserCtxtPtr ctxt) {
    xmlParserInputPtr ret;
    const char *fileID = NULL;
    /* lookup for the fileID depending on ID */
    ret = xmlNewInputFromFile(ctxt, fileID);
    if (ret != NULL)
        return(ret);
    if (defaultLoader != NULL)
        ret = defaultLoader(URL, ID, ctxt);
    return(ret);
}
int main(..) {
    ...
    /*
     * Install our own entity loader
     */
    defaultLoader = xmlGetExternalEntityLoader();
    xmlSetExternalEntityLoader(xmlMyExternalEntityLoader);
    ...
}This example come from areal use case,xmlDocDump()
closes the FILE * passed by the applicationand this was aproblem. The solutionwasto redefine anew
output handler with the closing call deactivated: First define a new I/O output allocator where the output don't
    closethefile:
    xmlOutputBufferPtr
xmlOutputBufferCreateOwn(FILE *file, xmlCharEncodingHandlerPtr encoder) {
    xmlOutputBufferPtr ret;
    
    if (xmlOutputCallbackInitialized == 0)
        xmlRegisterDefaultOutputCallbacks();
    if (file == NULL) return(NULL);
    ret = xmlAllocOutputBuffer(encoder);
    if (ret != NULL) {
        ret->context = file;
        ret->writecallback = xmlFileWrite;
        ret->closecallback = NULL;  /* No close callback */
    }
    return(ret);
} And then use it to save the document:
    FILE *f;
xmlOutputBufferPtr output;
xmlDocPtr doc;
int res;
f = ...
doc = ....
output = xmlOutputBufferCreateOwn(f, NULL);
res = xmlSaveFileTo(output, doc, NULL);
    
 Daniel Veillard |