dbChannel.h

Go to the documentation of this file.

/*************************************************************************\
* Copyright (c) 2010 UChicago Argonne LLC, as Operator of Argonne
*     National Laboratory.
* Copyright (c) 2010 Brookhaven National Laboratory.
* Copyright (c) 2010 Helmholtz-Zentrum Berlin
*     fuer Materialien und Energie GmbH.
* SPDX-License-Identifier: EPICS
* EPICS BASE is distributed subject to a Software License Agreement found
* in file LICENSE that is included with this distribution.
\*************************************************************************/

#ifndef INC_dbChannel_H
#define INC_dbChannel_H

#include "dbDefs.h"
#include "dbAddr.h"
#include "ellLib.h"
#include "epicsTypes.h"
#include "errMdef.h"
#include "db_field_log.h"
#include "dbEvent.h"
#include "dbCoreAPI.h"

#ifdef __cplusplus
extern "C" {
#endif

typedef struct evSubscrip {
    ELLNODE             node;
    struct dbChannel  * chan;
    EVENTFUNC         * user_sub;
    void              * user_arg;
    struct event_que  * ev_que;
    db_field_log     ** pLastLog;
    unsigned long       npend;      
    unsigned long       nreplace;   
    unsigned char       select;
    char                useValque;
    char                callBackInProgress;
    char                enabled;
} evSubscrip;

typedef struct chFilter chFilter;

typedef struct dbChannel {
    const char *name;         
    dbAddr addr;              
    long  final_no_elements;  
    short final_field_size;   
    short final_type;         
    ELLLIST filters;          
    ELLLIST pre_chain;        
    ELLLIST post_chain;       
} dbChannel;

typedef db_field_log* (chPostEventFunc)(void *pvt, dbChannel *chan, db_field_log *pLog);

typedef enum {
    parse_stop, parse_continue
} parse_result;

typedef struct chFilterIf {
    void (* priv_free)(void *puser);

    parse_result (* parse_start)(chFilter *filter);

    void (* parse_abort)(chFilter *filter);

    parse_result (* parse_end)(chFilter *filter);

    parse_result (* parse_null)(chFilter *filter);

    parse_result (* parse_boolean)(chFilter *filter, int boolVal);

    parse_result (* parse_integer)(chFilter *filter, long integerVal);

    parse_result (* parse_double)(chFilter *filter, double doubleVal);

    parse_result (* parse_string)(chFilter *filter, const char *stringVal,
            size_t stringLen);

    parse_result (* parse_start_map)(chFilter *filter);

    parse_result (* parse_map_key)(chFilter *filter, const char *key,
            size_t stringLen);

    parse_result (* parse_end_map)(chFilter *filter);

    parse_result (* parse_start_array)(chFilter *filter);

    parse_result (* parse_end_array)(chFilter *filter);

    long (* channel_open)(chFilter *filter);

    void (* channel_register_pre) (chFilter *filter,
        chPostEventFunc **cb_out, void **arg_out, db_field_log *probe);

    void (* channel_register_post)(chFilter *filter,
        chPostEventFunc **cb_out, void **arg_out, db_field_log *probe);

    void (* channel_report)(chFilter *filter,
        int level, const unsigned short indent);

    void (* channel_close)(chFilter *filter);
} chFilterIf;

typedef struct chFilterPlugin {
    ELLNODE node;           
    const char *name;       
    const chFilterIf *fif;  
    void *puser;            
} chFilterPlugin;

struct chFilter {
    ELLNODE list_node;          
    ELLNODE pre_node;           
    ELLNODE post_node;          
    dbChannel *chan;            
    const chFilterPlugin *plug; 
    chPostEventFunc *pre_func;  
    void *pre_arg;              
    chPostEventFunc *post_func; 
    void *post_arg;             
    void *puser;                
};

struct dbCommon;
struct dbFldDes;

DBCORE_API void dbChannelInit(void);

DBCORE_API void dbChannelExit(void);

DBCORE_API long dbChannelTest(const char *name);

DBCORE_API dbChannel * dbChannelCreate(const char *name);

DBCORE_API long dbChannelOpen(dbChannel *chan);

DBCORE_API extern unsigned short dbDBRnewToDBRold[];

#define dbChannelName(pChan) ((pChan)->name)

#define dbChannelRecord(pChan) ((pChan)->addr.precord)

#define dbChannelFldDes(pChan) ((pChan)->addr.pfldDes)

#define dbChannelElements(pChan) ((pChan)->addr.no_elements)

#define dbChannelFieldType(pChan) ((pChan)->addr.field_type)

#define dbChannelExportType(pChan) ((pChan)->addr.dbr_field_type)

#define dbChannelExportCAType(pChan) (dbDBRnewToDBRold[dbChannelExportType(pChan)])

#define dbChannelFieldSize(pChan) ((pChan)->addr.field_size)

#define dbChannelFinalElements(pChan) ((pChan)->final_no_elements)

#define dbChannelFinalFieldType(pChan) ((pChan)->final_type)

#define dbChannelFinalCAType(pChan) (dbDBRnewToDBRold[(pChan)->final_type])

#define dbChannelFinalFieldSize(pChan) ((pChan)->final_field_size)

#define dbChannelSpecial(pChan) ((pChan)->addr.special)

#define dbChannelField(pChan) ((pChan)->addr.pfield)


DBCORE_API long dbChannelGet(dbChannel *chan, short type,
        void *pbuffer, long *options, long *nRequest, void *pfl);

DBCORE_API long dbChannelGetField(dbChannel *chan, short type,
        void *pbuffer, long *options, long *nRequest, void *pfl);

DBCORE_API long dbChannelPut(dbChannel *chan, short type,
        const void *pbuffer, long nRequest);

DBCORE_API long dbChannelPutField(dbChannel *chan, short type,
        const void *pbuffer, long nRequest);

DBCORE_API void dbChannelShow(dbChannel *chan, int level,
        const unsigned short indent);

DBCORE_API void dbChannelFilterShow(dbChannel *chan, int level,
        const unsigned short indent);

DBCORE_API void dbChannelDelete(dbChannel *chan);


DBCORE_API void dbRegisterFilter(const char *key,
    const chFilterIf *fif, void *puser);
DBCORE_API db_field_log* dbChannelRunPreChain(dbChannel *chan,
    db_field_log *pLogIn);
DBCORE_API db_field_log* dbChannelRunPostChain(dbChannel *chan,
    db_field_log *pLogIn);
DBCORE_API const chFilterPlugin * dbFindFilter(const char *key, size_t len);
DBCORE_API void dbChannelGetArrayInfo(dbChannel *chan,
        void **pfield, long *no_elements, long *offset);

#ifdef __cplusplus
}
#endif

#endif /* INC_dbChannel_H */