/src/trunk2/BAL/Interfaces/BTXML.h

Go to the documentation of this file.

/*
 * Copyright (C) 2007 Pleyo.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1.  Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 * 2.  Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 * 3.  Neither the name of Pleyo nor the names of
 *     its contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY PLEYO AND ITS CONTRIBUTORS "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL PLEYO OR ITS CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef BTXML_H_
#define BTXML_H_


namespace BAL {
    
    class BTXMLNode;
    class BTXMLDoc;
    class BTXMLNs;
    class BTXMLDict;
    
    #define BTXML_ELEMENT_NODE                 1
    #define BTXML_TEXT_NODE                    3
    #define BTXML_HTML_DOCUMENT_NODE          13
    #define BTXML_CHAR_ENCODING_UTF16LE        2
    #define BTXML_CHAR_ENCODING_UTF16BE        3
    #define BTXML_ENTITY_DECL                 17
    #define BTXML_INTERNAL_PREDEFINED_ENTITY   6
    #define BTXML_SAX2_MAGIC 0xDEEDBEAF
     
    typedef enum {
        BTXML_PARSE_RECOVER   = 1<<0, /* recover on errors */
        BTXML_PARSE_NOENT     = 1<<1, /* substitute entities */
        BTXML_PARSE_DTDLOAD   = 1<<2, /* load the external subset */
        BTXML_PARSE_DTDATTR   = 1<<3, /* default DTD attributes */
        BTXML_PARSE_DTDVALID  = 1<<4, /* validate with the DTD */
        BTXML_PARSE_NOERROR   = 1<<5, /* suppress error reports */
        BTXML_PARSE_NOWARNING = 1<<6, /* suppress warning reports */
        BTXML_PARSE_PEDANTIC  = 1<<7, /* pedantic error reporting */
        BTXML_PARSE_NOBLANKS  = 1<<8, /* remove blank nodes */
        BTXML_PARSE_SAX1      = 1<<9, /* use the SAX1 interface internally */
        BTXML_PARSE_XINCLUDE  = 1<<10,/* Implement XInclude substitition  */
        BTXML_PARSE_NONET     = 1<<11,/* Forbid network access */
        BTXML_PARSE_NODICT    = 1<<12,/* Do not reuse the context dictionnary */
        BTXML_PARSE_NSCLEAN   = 1<<13,/* remove redundant namespaces declarations */
        BTXML_PARSE_NOCDATA   = 1<<14,/* merge CDATA as text nodes */
        BTXML_PARSE_NOXINCNODE= 1<<15,/* do not generate XINCLUDE START/END nodes */
        BTXML_PARSE_COMPACT   = 1<<16 /* compact small text nodes */
    } BTXMLParserOption;
    
    class BTXMLDoc
    {
        public:
            BTXMLDoc();
            BTXMLDoc( int t, BTXMLNode *c, const unsigned char *e );
            ~BTXMLDoc();
       
            int  type;        /* XML_DOCUMENT_NODE, must be second ! */
            BTXMLNode *children;  /* the document tree */
            const unsigned char *encoding;   /* external initial encoding, if any */
    };
    
    class BTXMLNs
    {
        public:
            BTXMLNs();
            BTXMLNs(const unsigned char *ref);
            ~BTXMLNs();
            
            const unsigned char *href;        /* URL for the namespace */
    };
    
    
    class BTXMLAttr
    {
        public:
            BTXMLAttr();
            BTXMLAttr( BTXMLNode *p );
            ~BTXMLAttr();
            
            BTXMLNode *parent;    /* child->parent link */
};

    
    class BTXMLNode
    {
        public:
            BTXMLNode();
            BTXMLNode(int t, const unsigned char *na, BTXMLNode *c, BTXMLNode *n, BTXMLNs *_ns, unsigned char *co );
            ~BTXMLNode();
            
            int  type;      /* type number, must be second ! */
            const unsigned char *name;      /* the name of the node, or the entity */
            BTXMLNode *children;  /* parent->childs link */
            BTXMLNode *next;      /* next sibling link  */
        
            /* End of common part */
            BTXMLNs         *ns;        /* pointer to the associated namespace */
            unsigned char   *content;   /* the content */
    };
    
    class BTXMLHashTable
    {
        public:
            BTXMLHashTable(){};
            ~BTXMLHashTable(){};
       
    };
    
    class BTXMLDict
    {
        public:
            BTXMLDict(){};
            ~BTXMLDict(){};
       
    };
    
    typedef int (* BTXMLCharEncodingInputFunc)(unsigned char *out, int *outlen,
                                            const unsigned char *in, int *inlen);

    typedef int (* BTXMLCharEncodingOutputFunc)(unsigned char *out, int *outlen,
                                            const unsigned char *in, int *inlen);

    class BTXMLCharEncodingHandler
    {
        public:
            BTXMLCharEncodingHandler();
            ~BTXMLCharEncodingHandler();

    };


    typedef int (* BTXMLOutputWriteCallback) (void * context, const char * buffer, int len);

    
    class BTXMLBuffer 
    {
        public:
            BTXMLBuffer();
            BTXMLBuffer( unsigned char *c );
            ~BTXMLBuffer();
        
            unsigned char *content;     /* The buffer content UTF8 */
    };

    class BTXMLOutputBuffer
    {
        public:
            BTXMLOutputBuffer();
            BTXMLOutputBuffer( void *c, BTXMLOutputWriteCallback wc );
            ~BTXMLOutputBuffer();
            
            void*                   context;
            BTXMLOutputWriteCallback  writecallback;
    };
    
    
    class BTXMLParserInput
    {
        public:
            BTXMLParserInput();
            BTXMLParserInput( int l, int c);
            ~BTXMLParserInput();
            
            int line;                         /* Current line */
            int col;                          /* Current column */
    };
    
    
    typedef void (*BTXMLGenericErrorFunc) (void *ctx, const char *msg, ...);

    class BTXMLParserCtxt
    {
        public :
        
            BTXMLParserCtxt();
            BTXMLParserCtxt(void *_p, int r, BTXMLNode *n, BTXMLDoc *d, BTXMLParserInput *pi );
            ~BTXMLParserCtxt();
            
            void        *_private;      /* For user data, libxml won't touch it */
            int         replaceEntities;        /* shall we replace entities ? */
            BTXMLNode   *node;          /* Current parsed Node */
            BTXMLDoc    *myDoc;        /* the document being built */
            BTXMLParserInput  *input;         /* Current input stream */
    };
    
    typedef void (*BTErrorSAXFunc) (void *ctx, const char *msg, ...);

    typedef void (*BTFatalErrorSAXFunc) (void *ctx, const char *msg, ...);
    
    typedef void (*BTCharactersSAXFunc) (void *ctx, const unsigned char *ch, int len);

    typedef void (*BTProcessingInstructionSAXFunc) (void *ctx, const unsigned char *target, const unsigned char *data);
    
    
    typedef void (*BTCdataBlockSAXFunc) ( void *ctx, const unsigned char *value, int len);
    
    typedef void (*BTCommentSAXFunc) (void *ctx, const unsigned char *value);
    
    typedef void (*BTWarningSAXFunc) (void *ctx,  const char *msg, ...);
    
    typedef void (*BTStartElementNsSAX2Func) (void *ctx,
                                            const unsigned char *localname,
                                            const unsigned char *prefix,
                                            const unsigned char *URI,
                                            int nb_namespaces,
                                            const unsigned char **namespaces,
                                            int nb_attributes,
                                            int nb_defaulted,
                                            const unsigned char **attributes);

    typedef void (*BTEndElementNsSAX2Func)   (void *ctx,
                                              const unsigned char *localname,
                                              const unsigned char *prefix,
                                              const unsigned char *URI);

    typedef void (*BTStartDocumentSAXFunc) (void *ctx);

    class BTXMLEntity;
    typedef BTXMLEntity* (*BTGetEntitySAXFunc) (void *ctx, const unsigned char *name);

    typedef void (*BTInternalSubsetSAXFunc) (void *ctx,
                                    const unsigned char *name,
                                    const unsigned char *ExternalID,
                                    const unsigned char *SystemID);

    typedef void (*BTExternalSubsetSAXFunc) (void *ctx,
                                    const unsigned char *name,
                                    const unsigned char *ExternalID,
                                    const unsigned char *SystemID);

    typedef void (*BTIgnorableWhitespaceSAXFunc) (void *ctx,
                                    const unsigned char *ch,
                                    int len);

    typedef void (*BTEntityDeclSAXFunc) (void *ctx,
                                    const unsigned char *name,
                                    int type,
                                    const unsigned char *publicId,
                                    const unsigned char *systemId,
                                    unsigned char *content);


    class BTXMLSAXHandler
    {
        public:
            BTXMLSAXHandler();
            ~BTXMLSAXHandler();
            
            BTErrorSAXFunc error;
            BTFatalErrorSAXFunc fatalError;
            BTCharactersSAXFunc characters;
            BTProcessingInstructionSAXFunc processingInstruction;
            BTCdataBlockSAXFunc cdataBlock;
            BTCommentSAXFunc comment;
            BTWarningSAXFunc warning;
            BTStartElementNsSAX2Func startElementNs;
            BTEndElementNsSAX2Func endElementNs;
            BTGetEntitySAXFunc getEntity;
            BTStartDocumentSAXFunc startDocument;
            BTInternalSubsetSAXFunc internalSubset;
            BTExternalSubsetSAXFunc externalSubset;
            BTIgnorableWhitespaceSAXFunc ignorableWhitespace;
            BTEntityDeclSAXFunc entityDecl;
            unsigned int initialized;
    };
    
    typedef int (*BTXMLInputMatchCallback) (char const *filename);
    
    typedef void * (*BTXMLInputOpenCallback) (char const *filename);
    
    typedef int (*BTXMLInputReadCallback) (void * context, char * buffer, int len);
    
    typedef int (*BTXMLInputCloseCallback) (void * context);
    
    
    typedef int (*BTXMLOutputMatchCallback) (char const *filename);
    typedef void * (*BTXMLOutputOpenCallback) (char const *filename);
    typedef int (*BTXMLOutputWriteCallback) (void * context, const char * buffer, int len);
    typedef int (*BTXMLOutputCloseCallback) (void * context);
    
    
    class BTXMLEntity
    {
        public:
            BTXMLEntity();
            BTXMLEntity( int t, const unsigned char *n, unsigned char *o, unsigned char *ct, int l, int et );
            ~BTXMLEntity();
            
            int                 type;       /* XML_ENTITY_DECL, must be second ! */
            const unsigned char *name;       /* Entity name */
            unsigned char       *orig;       /* content without ref substitution */
            unsigned char       *content;       /* content or ndata if unparsed */
            int                 length;       /* the content length */
            int                 etype;       /* The entity type */
    };
    
}

#endif // BTXML_H_

---

pleyo.com