lixa_iface.h

Go to the documentation of this file.

/*
 * Copyright (c) 2009-2019, Christian Ferrari <tiian@users.sourceforge.net>
 * All rights reserved.
 *
 * This file is part of LIXA.
 *
 * LIXA is free software: you can redistribute this file and/or modify
 * it under the terms of the GNU Lesser General Public License version 2.1 as
 * published by the Free Software Foundation.
 *
 * LIXA is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with LIXA.  If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef LIXA_IFACE_H
# define LIXA_IFACE_H



#include "xa.h"
#include "xta_iface.h"



/* save old LIXA_TRACE_MODULE and set a new value */
#ifdef LIXA_TRACE_MODULE
# define LIXA_TRACE_MODULE_SAVE LIXA_TRACE_MODULE
# undef LIXA_TRACE_MODULE
#else
# undef LIXA_TRACE_MODULE_SAVE
#endif /* LIXA_TRACE_MODULE */
#define LIXA_TRACE_MODULE      LIXA_TRACE_MOD_CLIENT_CONFIG



#define LIXA_IFACE_STD     0

#define LIXA_IFACE_XTA     1



/*
 * This type is a declaration only statement: the real type is defined inside
 * XA Resource header file. Here we just need to store a pointer to
 * a XA Resource inside LIXA interface.
 */
typedef struct xta_xa_resource_s xta_xa_resource_t;



typedef struct lixa_iface_s {
    int                       type;
    union {
        struct xa_switch_t   *std;
        const struct xta_iface_s   *xta;
    };
    xta_xa_resource_t        *context;
} lixa_iface_t;



#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

    

    void lixa_iface_reset(lixa_iface_t *iface);
    
    

    void lixa_iface_set_std(lixa_iface_t *iface, struct xa_switch_t *std);



    void lixa_iface_set_xta(lixa_iface_t *iface, const struct xta_iface_s *xta,
                            xta_xa_resource_t *context);



    static inline long lixa_iface_get_flags(const lixa_iface_t *iface) {
        if (LIXA_IFACE_STD == iface->type)
            return iface->std->flags;
        else
            return iface->xta->flags;
    }


    
    static inline const char *lixa_iface_get_name(const lixa_iface_t *iface) {
        if (LIXA_IFACE_STD == iface->type)
            return iface->std->name;
        else
            return iface->xta->name;
    }

    

    static inline int lixa_iface_xa_open(lixa_iface_t *iface, char *info,
                                         int rmid, long flags) {
        if (LIXA_IFACE_STD == iface->type)
            return iface->std->xa_open_entry(info, rmid, flags);
        else
            return iface->xta->xa_open_entry(iface->context, info,
                                             rmid, flags);
    }



    static inline int lixa_iface_xa_close(lixa_iface_t *iface, char *info,
                                          int rmid, long flags) {
        if (LIXA_IFACE_STD == iface->type)
            return iface->std->xa_close_entry(info, rmid, flags);
        else
            return iface->xta->xa_close_entry(iface->context, info,
                                              rmid, flags);
    }



    static inline int lixa_iface_xa_start(lixa_iface_t *iface, const XID *xid,
                                          int rmid, long flags) {
        if (LIXA_IFACE_STD == iface->type)
            return iface->std->xa_start_entry((XID *)xid, rmid, flags);
        else
            return iface->xta->xa_start_entry(iface->context, xid,
                                              rmid, flags);
    }


    
    static inline int lixa_iface_xa_commit(lixa_iface_t *iface,
        const XID *xid, int rmid, long flags) {
    if (LIXA_IFACE_STD == iface->type)
        return iface->std->xa_commit_entry((XID *)xid,rmid,flags);
        else
            return iface->xta->xa_commit_entry(
                iface->context, xid, rmid, flags);
    }


    
    static inline int lixa_iface_xa_rollback(lixa_iface_t *iface,
                                             const XID *xid, int rmid,
                                             long flags) {
        if (LIXA_IFACE_STD == iface->type)
            return iface->std->xa_rollback_entry((XID *)xid, rmid, flags);
        else
            return iface->xta->xa_rollback_entry(
                iface->context, xid, rmid, flags);
    }


    
    static inline int lixa_iface_xa_recover(lixa_iface_t *iface,
                                            XID *xids, long count,
                                            int rmid, long flags) {
        if (LIXA_IFACE_STD == iface->type)
            return iface->std->xa_recover_entry(
                (XID *)xids,count,rmid,flags);
        else
            return iface->xta->xa_recover_entry(
                iface->context,xids,count,rmid,flags);
    }


    
    static inline int lixa_iface_xa_forget(lixa_iface_t *iface,
        const XID *xid, int rmid, long flags) {
    if (LIXA_IFACE_STD == iface->type)
        return iface->std->xa_forget_entry((XID *)xid, rmid, flags);
        else
            return iface->xta->xa_forget_entry(
                iface->context, xid, rmid, flags);
    }


    
    static inline int lixa_iface_xa_end(lixa_iface_t *iface,
        const XID *xid, int rmid, long flags) {
    if (LIXA_IFACE_STD == iface->type)
        return iface->std->xa_end_entry((XID *)xid, rmid, flags);
        else
            return iface->xta->xa_end_entry(iface->context, xid, rmid, flags);
    }


    
    static inline int lixa_iface_xa_prepare(lixa_iface_t *iface,
        const XID *xid, int rmid, long flags) {
    if (LIXA_IFACE_STD == iface->type)
        return iface->std->xa_prepare_entry((XID *)xid, rmid, flags);
        else
            return iface->xta->xa_prepare_entry(
                iface->context, xid, rmid, flags);
    }


    
#ifdef __cplusplus
}
#endif /* __cplusplus */



/* restore old value of LIXA_TRACE_MODULE */
#ifdef LIXA_TRACE_MODULE_SAVE
# undef LIXA_TRACE_MODULE
# define LIXA_TRACE_MODULE LIXA_TRACE_MODULE_SAVE
# undef LIXA_TRACE_MODULE_SAVE
#endif /* LIXA_TRACE_MODULE_SAVE */



#endif /* LIXA_IFACE_H */