xqc.h

Go to the documentation of this file.

/*
 * Copyright (c) 2008, Matthias Brantner, John Snelson
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *     * Redistributions of source code must retain the above copyright notice,
 *       this list of conditions and the following disclaimer.
 *     * 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.
 *     * Neither the name of the developers nor the names of contributors may be
 *       used to endorse or promote products derived from this software without
 *       specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT OWNER OR 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 _XQUERY_C_API_H
#define _XQUERY_C_API_H

/* Include stdio for FILE */
#include <stdio.h>

#ifdef __cplusplus
extern "C" {
#endif

#define XQC_VERSION_NUMBER 1

typedef struct XQC_Implementation_s XQC_Implementation;
typedef struct XQC_StaticContext_s XQC_StaticContext;
typedef struct XQC_Expression_s XQC_Expression;
typedef struct XQC_DynamicContext_s XQC_DynamicContext;
typedef struct XQC_Sequence_s XQC_Sequence;
typedef struct XQC_InputStream_s XQC_InputStream;
typedef struct XQC_ErrorHandler_s XQC_ErrorHandler;

typedef enum {
        XQC_NO_ERROR = 0,          
        XQC_END_OF_SEQUENCE,       
        XQC_NO_CURRENT_ITEM,
        XQC_PARSE_ERROR,
        XQC_INVALID_ARGUMENT,
        XQC_NOT_NODE,

        XQC_INTERNAL_ERROR,        
        XQC_NOT_IMPLEMENTED,       

        XQC_UNRECOGNIZED_ENCODING,

        XQC_STATIC_ERROR,          
        XQC_TYPE_ERROR,            
        XQC_DYNAMIC_ERROR,         
        XQC_SERIALIZATION_ERROR    
} XQC_Error;

struct XQC_InputStream_s {
        const char *encoding;

        void *user_data;

        unsigned int (*read)(XQC_InputStream *stream, void *buffer, unsigned int length);

        void (*free)(XQC_InputStream *stream);
};

struct XQC_ErrorHandler_s {

        void *user_data;

        void (*error)(XQC_ErrorHandler *handler, XQC_Error error, const char *error_uri,
                const char *error_localname, const char *description, XQC_Sequence *error_object);
};

typedef enum {
        XQC_EMPTY_TYPE = 0,

        XQC_DOCUMENT_TYPE,
        XQC_ELEMENT_TYPE,
        XQC_ATTRIBUTE_TYPE,
        XQC_TEXT_TYPE,
        XQC_PROCESSING_INSTRUCTION_TYPE,
        XQC_COMMENT_TYPE,
        XQC_NAMESPACE_TYPE,

        XQC_ANY_SIMPLE_TYPE,
        XQC_ANY_URI_TYPE,
        XQC_BASE_64_BINARY_TYPE,
        XQC_BOOLEAN_TYPE,
        XQC_DATE_TYPE,
        XQC_DATE_TIME_TYPE,
        XQC_DAY_TIME_DURATION_TYPE,
        XQC_DECIMAL_TYPE,
        XQC_DOUBLE_TYPE,
        XQC_DURATION_TYPE,
        XQC_FLOAT_TYPE,
        XQC_G_DAY_TYPE,
        XQC_G_MONTH_TYPE,
        XQC_G_MONTH_DAY_TYPE,
        XQC_G_YEAR_TYPE,
        XQC_G_YEAR_MONTH_TYPE,
        XQC_HEX_BINARY_TYPE,
        XQC_NOTATION_TYPE,
        XQC_QNAME_TYPE,
        XQC_STRING_TYPE,
        XQC_TIME_TYPE,
        XQC_UNTYPED_ATOMIC_TYPE,
        XQC_YEAR_MONTH_DURATION_TYPE
        
} XQC_ItemType;

struct XQC_Implementation_s {

        XQC_Error (*create_context)(XQC_Implementation *implementation, XQC_StaticContext **context);

        XQC_Error (*prepare)(XQC_Implementation *implementation, const char *string,
                const XQC_StaticContext *context, XQC_Expression **expression);

        XQC_Error (*prepare_file)(XQC_Implementation *implementation, FILE *file,
                const XQC_StaticContext *context, XQC_Expression **expression);

        XQC_Error (*prepare_stream)(XQC_Implementation *implementation, XQC_InputStream *stream,
                const XQC_StaticContext *context, XQC_Expression **expression);


        XQC_Error (*parse_document)(XQC_Implementation *implementation,
                const char *string, XQC_Sequence **sequence);
        XQC_Error (*parse_document_file)(XQC_Implementation *implementation,
                FILE *file, XQC_Sequence **sequence);
        XQC_Error (*parse_document_stream)(XQC_Implementation *implementation,
                XQC_InputStream *stream, XQC_Sequence **sequence);


        XQC_Error (*create_empty_sequence)(XQC_Implementation *implementation,
                XQC_Sequence **sequence);
        XQC_Error (*create_singleton_sequence)(XQC_Implementation *implementation,
                XQC_ItemType type, const char *value,
                XQC_Sequence **sequence);
        XQC_Error (*create_string_sequence)(XQC_Implementation *implementation,
                const char *values[], unsigned int count,
                XQC_Sequence **sequence);
        XQC_Error (*create_integer_sequence)(XQC_Implementation *implementation,
                int values[], unsigned int count,
                XQC_Sequence **sequence);
        XQC_Error (*create_double_sequence)(XQC_Implementation *implementation,
                double values[], unsigned int count,
                XQC_Sequence **sequence);


        void *(*get_interface)(const XQC_Implementation *implementation, const char *name);

        void (*free)(XQC_Implementation *implementation);
};

typedef enum { XQC_XPATH2_0, XQC_XPATH1_0 } XQC_XPath1Mode;

typedef enum { XQC_ORDERED, XQC_UNORDERED } XQC_OrderingMode;

typedef enum { XQC_EMPTY_GREATEST, XQC_EMPTY_LEAST } XQC_OrderEmptyMode;

typedef enum { XQC_INHERIT_NS, XQC_NO_INHERIT_NS } XQC_InheritMode;

typedef enum { XQC_PRESERVE_NS, XQC_NO_PRESERVE_NS } XQC_PreserveMode;

typedef enum { XQC_PRESERVE_SPACE, XQC_STRIP_SPACE } XQC_BoundarySpaceMode;

typedef enum { XQC_PRESERVE_CONS, XQC_STRIP_CONS } XQC_ConstructionMode;

struct XQC_StaticContext_s {

        XQC_Error
        (*create_child_context)(XQC_StaticContext *context, XQC_StaticContext **child_context);

        XQC_Error
        (*declare_ns)(XQC_StaticContext *context, const char *prefix, const char *uri);

        XQC_Error
        (*get_ns_by_prefix)(XQC_StaticContext *context, const char *prefix, const char **result_ns);

        XQC_Error
        (*set_default_element_and_type_ns)(XQC_StaticContext *context, const char *uri);

        XQC_Error
        (*get_default_element_and_type_ns)(XQC_StaticContext *context, const char **uri);

        XQC_Error
        (*set_default_function_ns)(XQC_StaticContext *context, const char *uri);

        XQC_Error
        (*get_default_function_ns)(XQC_StaticContext *context, const char **uri);

        XQC_Error
        (*set_xpath_compatib_mode)(XQC_StaticContext *context, XQC_XPath1Mode mode);

        XQC_Error 
        (*get_xpath_compatib_mode)(XQC_StaticContext *context, XQC_XPath1Mode* mode);

        XQC_Error
        (*set_construction_mode)(XQC_StaticContext *context, XQC_ConstructionMode mode);

        XQC_Error
        (*get_construction_mode)(XQC_StaticContext *context, XQC_ConstructionMode* mode);

        XQC_Error
        (*set_ordering_mode)(XQC_StaticContext *context, XQC_OrderingMode mode);

        XQC_Error
        (*get_ordering_mode)(XQC_StaticContext *context, XQC_OrderingMode* mode);

        XQC_Error
        (*set_default_order_empty_sequences)(XQC_StaticContext *context, XQC_OrderEmptyMode mode);

        XQC_Error
        (*get_default_order_empty_sequences)(XQC_StaticContext *context, XQC_OrderEmptyMode* mode);

        XQC_Error  
        (*set_boundary_space_policy)(XQC_StaticContext *context, XQC_BoundarySpaceMode mode);

        XQC_Error
        (*get_boundary_space_policy)(XQC_StaticContext *context, XQC_BoundarySpaceMode* mode);

        XQC_Error 
        (*set_copy_ns_mode)(XQC_StaticContext *context, XQC_PreserveMode preserve, XQC_InheritMode inherit);

        XQC_Error
        (*get_copy_ns_mode)(XQC_StaticContext *context, XQC_PreserveMode* preserve, XQC_InheritMode* inherit);

        XQC_Error
        (*set_base_uri)(XQC_StaticContext *context, const char *base_uri);

        XQC_Error
        (*get_base_uri)(XQC_StaticContext *context, const char **base_uri);

        XQC_Error (*set_error_handler)(XQC_StaticContext *context, XQC_ErrorHandler *handler);
        XQC_Error (*get_error_handler)(const XQC_StaticContext *context, XQC_ErrorHandler **handler);

        void *(*get_interface)(const XQC_StaticContext *context, const char *name);

        void (*free)(XQC_StaticContext *context);
};

struct XQC_Expression_s {

        XQC_Error (*create_context)(const XQC_Expression *expression, XQC_DynamicContext **context);

        XQC_Error (*execute)(const XQC_Expression *expression, const XQC_DynamicContext *context, XQC_Sequence **sequence);

        void *(*get_interface)(const XQC_Expression *expression, const char *name);

        void (*free)(XQC_Expression *expression);
};

struct XQC_DynamicContext_s {
        XQC_Error (*set_variable)(XQC_DynamicContext *context, const char *uri, const char *name,
                XQC_Sequence *value);

        XQC_Error (*get_variable)(const XQC_DynamicContext *context, const char *uri, const char *name,
                XQC_Sequence **value);

        XQC_Error (*set_context_item)(XQC_DynamicContext *context, XQC_Sequence *value);

        XQC_Error (*get_context_item)(const XQC_DynamicContext *context, XQC_Sequence **value);

        XQC_Error (*set_implicit_timezone)(XQC_DynamicContext *context, int timezone);
        XQC_Error (*get_implicit_timezone)(const XQC_DynamicContext *context, int *timezone);

        XQC_Error (*set_error_handler)(XQC_DynamicContext *context, XQC_ErrorHandler *handler);
        XQC_Error (*get_error_handler)(const XQC_DynamicContext *context, XQC_ErrorHandler **handler);

        void *(*get_interface)(const XQC_DynamicContext *context, const char *name);

        void (*free)(XQC_DynamicContext *context);
};

struct XQC_Sequence_s {
        XQC_Error (*next)(XQC_Sequence *sequence);

        XQC_Error (*item_type)(const XQC_Sequence *sequence, XQC_ItemType *type);

        XQC_Error (*type_name)(const XQC_Sequence *sequence, const char **uri, const char **name);

        XQC_Error (*string_value)(const XQC_Sequence *sequence, const char **value);

        XQC_Error (*integer_value)(const XQC_Sequence *sequence, int *value);

        XQC_Error (*double_value)(const XQC_Sequence *sequence, double *value);

        XQC_Error (*node_name)(const XQC_Sequence *sequence, const char **uri, const char **name);

        void *(*get_interface)(const XQC_Sequence *sequence, const char *name);

        void (*free)(XQC_Sequence *sequence);
};

#ifdef  __cplusplus
}
#endif

#endif