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

struct evSubscrip;

typedef struct evSubscrip evSubscrip;

#ifdef EPICS_PRIVATE_API
struct evSubscrip {
 ELLNODE node;
 struct dbChannel * chan;
 /* user_sub==NULL used to indicate db_cancel_event() */
 EVENTFUNC * user_sub;
 void * user_arg;
 /* associated queue, may be shared with other evSubscrip */
 struct event_que * ev_que;
 /* NULL if !npend. if npend!=0, pointer to last event added to event_que::valque */
 db_field_log ** pLastLog;
 /* n times this event is on the queue */
 unsigned long npend;
 /* n times replacing event on the queue */
 unsigned long nreplace;
 /* DBE mask */
 unsigned char select;
 /* if set, subscription will yield dbfl_type_val */
 char useValque;
 /* event_task is handling this subscription */
 char callBackInProgress;
 /* this node added to dbCommon::mlis */
 char enabled;
};
#endif

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 */