#include <stdarg.h>
#include "epicsThread.h"
#include "libCaAPI.h"
#include "caerr.h"
#include "db_access.h"
#include "caeventmask.h"

Include dependency graph for cadef.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	connection_handler_args

struct	ca_access_rights

struct	access_rights_handler_args

struct	event_handler_args

struct	exception_handler_args

Macros
#define	VALID_TYPE(TYPE) (((unsigned short)TYPE)<=LAST_BUFFER_TYPE)

#define	CA_OP_GET 0

#define	CA_OP_PUT 1

#define	CA_OP_CREATE_CHANNEL 2

#define	CA_OP_ADD_EVENT 3

#define	CA_OP_CLEAR_EVENT 4

#define	CA_OP_OTHER 5

#define	CA_OP_CONN_UP 6

#define	CA_OP_CONN_DOWN 7

#define	CA_OP_SEARCH 2

#define	SEVCHK(CA_ERROR_CODE, MESSAGE_STRING)

#define	TYPENOTCONN (-1) /* the channel's native type when disconnected */

#define	CA_PRIORITY_MAX 99

#define	CA_PRIORITY_MIN 0

#define	CA_PRIORITY_DEFAULT CA_PRIORITY_MIN

#define	CA_PRIORITY_DB_LINKS 80

#define	CA_PRIORITY_ARCHIVE 20

#define	CA_PRIORITY_OPI 0

#define	ca_bput(chan, pValue) ca_array_put(DBR_STRING, 1u, chan, (const dbr_string_t *) (pValue))

#define	ca_rput(chan, pValue) ca_array_put(DBR_FLOAT, 1u, chan, (const dbr_float_t *) pValue)

#define	ca_put(type, chan, pValue) ca_array_put (type, 1u, chan, pValue)

#define	ca_put_callback(type, chan, pValue, pFunc, pArg) ca_array_put_callback(type, 1u, chan, pValue, pFunc, pArg)

#define	ca_bget(chan, pValue) ca_array_get(DBR_STRING, 1u, chan, (dbr_string_t *)(pValue))

#define	ca_rget(chan, pValue) ca_array_get(DBR_FLOAT, 1u, chan, (dbr_float_t *)(pValue))

#define	ca_get(type, chan, pValue) ca_array_get(type, 1u, chan, pValue)

#define	ca_bget_callback(chan, pFunc, pArg) ca_array_get_callback (DBR_STRING, 1u, chan, pFunc, pArg)

#define	ca_rget_callback(chan, pFunc, pArg) ca_array_get_callback (DBR_FLOAT, 1u, chan, pFunc, pArg)

#define	ca_get_callback(type, chan, pFunc, pArg) ca_array_get_callback (type, 1u, chan, pFunc, pArg)

#define	ca_poll() ca_pend_event(1e-12)

#define	ca_sg_get(gid, type, chan, pValue) ca_sg_array_get (gid, type, 1u, chan, pValue)

#define	ca_sg_put(gid, type, chan, pValue) ca_sg_array_put (gid, type, 1u, chan, pValue)

#define	ca_build_channel(NAME, XXXXX, CHIDPTR, YYYYY) ca_build_and_connect(NAME, XXXXX, 1, CHIDPTR, YYYYY, 0, 0)

#define	ca_array_build(NAME, XXXXX, ZZZZZZ, CHIDPTR, YYYYY) ca_build_and_connect(NAME, XXXXX, ZZZZZZ, CHIDPTR, YYYYY, 0, 0)

#define	ca_search(pChanName, pChanID) ca_search_and_connect (pChanName, pChanID, 0, 0)

#define	ca_add_event(type, chan, pFunc, pArg, pEventID) ca_add_array_event(type,1u,chan,pFunc,pArg,0.0,0.0,0.0,pEventID)

#define	ca_add_delta_event(TYPE, CHID, ENTRY, ARG, DELTA, EVID) ca_add_array_event(TYPE,1,CHID,ENTRY,ARG,DELTA,DELTA,0.0,EVID)

#define	ca_add_general_event(TYPE, CHID, ENTRY, ARG, P_DELTA, N_DELTA, TO, EVID) ca_add_array_event(TYPE,1,CHID,ENTRY,ARG,P_DELTA,N_DELTA,TO,EVID)

#define	ca_add_array_event(TYPE, COUNT, CHID, ENTRY, ARG, P_DELTA, N_DELTA, TO, EVID) ca_add_masked_array_event(TYPE,COUNT,CHID,ENTRY,ARG,P_DELTA,N_DELTA,TO,EVID, DBE_VALUE \| DBE_ALARM)

Typedefs
typedef struct oldChannelNotify *	chid

typedef chid	chanId

typedef long	chtype

typedef struct oldSubscription *	evid

typedef double	ca_real

typedef void	caCh(struct connection_handler_args args)

typedef struct ca_access_rights	caar

typedef void	caArh(struct access_rights_handler_args args)

typedef struct event_handler_args	evargs

typedef void	caEventCallBackFunc(struct event_handler_args)

typedef unsigned	CA_SYNC_GID

typedef unsigned	capri

typedef void	caExceptionHandler(struct exception_handler_args)

typedef void	CAFDHANDLER(void *parg, int fd, int opened)

typedef int	caPrintfFunc(const char *pformat, va_list args)

Enumerations
enum	channel_state { cs_never_conn, cs_prev_conn, cs_conn, cs_closed }

enum	ca_preemptive_callback_select { ca_disable_preemptive_callback, ca_enable_preemptive_callback }

Functions
LIBCA_API void epicsStdCall	ca_test_event (struct event_handler_args)

LIBCA_API short epicsStdCall	ca_field_type (chid chan)

LIBCA_API unsigned long epicsStdCall	ca_element_count (chid chan)

LIBCA_API const char *epicsStdCall	ca_name (chid chan)

LIBCA_API void epicsStdCall	ca_set_puser (chid chan, void *puser)

LIBCA_API void *epicsStdCall	ca_puser (chid chan)

LIBCA_API unsigned epicsStdCall	ca_read_access (chid chan)

LIBCA_API unsigned epicsStdCall	ca_write_access (chid chan)

LIBCA_API enum channel_state epicsStdCall	ca_state (chid chan)

LIBCA_API int epicsStdCall	ca_task_initialize (void)

LIBCA_API int epicsStdCall	ca_context_create (enum ca_preemptive_callback_select select)

LIBCA_API void epicsStdCall	ca_detach_context ()

LIBCA_API int epicsStdCall	ca_task_exit (void)

LIBCA_API void epicsStdCall	ca_context_destroy (void)

LIBCA_API int epicsStdCall	ca_create_channel (const char pChanName, caCh pConnStateCallback, void pUserPrivate, capri priority, chid pChanID)

LIBCA_API int epicsStdCall	ca_change_connection_event (chid chan, caCh *pfunc)

LIBCA_API int epicsStdCall	ca_replace_access_rights_event (chid chan, caArh *pfunc)

LIBCA_API int epicsStdCall	ca_add_exception_event (caExceptionHandler pfunc, void pArg)

LIBCA_API int epicsStdCall	ca_clear_channel (chid chanId)

LIBCA_API int epicsStdCall	ca_array_put (chtype type, unsigned long count, chid chanId, const void *pValue)

LIBCA_API int epicsStdCall	ca_array_put_callback (chtype type, unsigned long count, chid chanId, const void pValue, caEventCallBackFunc pFunc, void *pArg)

LIBCA_API int epicsStdCall	ca_array_get (chtype type, unsigned long count, chid chanId, void *pValue)

LIBCA_API int epicsStdCall	ca_array_get_callback (chtype type, unsigned long count, chid chanId, caEventCallBackFunc pFunc, void pArg)

LIBCA_API int epicsStdCall	ca_create_subscription (chtype type, unsigned long count, chid chanId, long mask, caEventCallBackFunc pFunc, void pArg, evid *pEventID)

LIBCA_API int epicsStdCall	ca_clear_subscription (evid eventID)

LIBCA_API chid epicsStdCall	ca_evid_to_chid (evid id)

LIBCA_API int epicsStdCall	ca_pend_event (ca_real timeOut)

LIBCA_API int epicsStdCall	ca_pend_io (ca_real timeOut)

LIBCA_API int epicsStdCall	ca_pend (ca_real timeout, int early)

LIBCA_API int epicsStdCall	ca_test_io (void)

LIBCA_API int epicsStdCall	ca_flush_io (void)

LIBCA_API void epicsStdCall	ca_signal (long errorCode, const char *pCtxStr)

LIBCA_API void epicsStdCall	ca_signal_with_file_and_lineno (long errorCode, const char pCtxStr, const char pFileStr, int lineNo)

LIBCA_API void epicsStdCall	ca_signal_formated (long ca_status, const char pfilenm, int lineno, const char pFormat,...)

LIBCA_API const char *epicsStdCall	ca_host_name (chid channel)

LIBCA_API unsigned epicsStdCall	ca_get_host_name (chid pChan, char *pBuf, unsigned bufLength)

LIBCA_API int epicsStdCall	ca_add_fd_registration (CAFDHANDLER pHandler, void pArg)

LIBCA_API int epicsStdCall	ca_sg_create (CA_SYNC_GID *pgid)

LIBCA_API int epicsStdCall	ca_sg_delete (const CA_SYNC_GID gid)

LIBCA_API int epicsStdCall	ca_sg_block (const CA_SYNC_GID gid, ca_real timeout)

LIBCA_API int epicsStdCall	ca_sg_test (const CA_SYNC_GID gid)

LIBCA_API int epicsStdCall	ca_sg_reset (const CA_SYNC_GID gid)

LIBCA_API int epicsStdCall	ca_sg_array_get (const CA_SYNC_GID gid, chtype type, unsigned long count, chid chan, void *pValue)

LIBCA_API int epicsStdCall	ca_sg_array_put (const CA_SYNC_GID gid, chtype type, unsigned long count, chid chan, const void *pValue)

LIBCA_API int epicsStdCall	ca_sg_stat (CA_SYNC_GID gid)

LIBCA_API void epicsStdCall	ca_dump_dbr (chtype type, unsigned count, const void *pbuffer)

LIBCA_API int epicsStdCall	ca_v42_ok (chid chan)

LIBCA_API const char *epicsStdCall	ca_version (void)

LIBCA_API int epicsStdCall	ca_replace_printf_handler (caPrintfFunc *ca_printf_func)

LIBCA_API unsigned epicsStdCall	ca_get_ioc_connection_count (void)

LIBCA_API int epicsStdCall	ca_preemtive_callback_is_enabled (void)

LIBCA_API void epicsStdCall	ca_self_test (void)

LIBCA_API unsigned epicsStdCall	ca_beacon_anomaly_count (void)

LIBCA_API unsigned epicsStdCall	ca_search_attempts (chid chan)

LIBCA_API double epicsStdCall	ca_beacon_period (chid chan)

LIBCA_API double epicsStdCall	ca_receive_watchdog_delay (chid chan)

LIBCA_API struct ca_client_context *epicsStdCall	ca_current_context ()

LIBCA_API int epicsStdCall	ca_attach_context (struct ca_client_context *context)

LIBCA_API int epicsStdCall	ca_client_status (unsigned level)

LIBCA_API int epicsStdCall	ca_context_status (struct ca_client_context *, unsigned level)

LIBCA_API int epicsStdCall	ca_build_and_connect (const char pChanName, chtype, unsigned long, chid pChanID, void , caCh pFunc, void *pArg)

LIBCA_API int epicsStdCall	ca_search_and_connect (const char pChanName, chid pChanID, caCh pFunc, void pArg)

LIBCA_API int epicsStdCall	ca_channel_status (epicsThreadId tid)

LIBCA_API int epicsStdCall	ca_clear_event (evid eventID)

LIBCA_API int epicsStdCall	ca_add_masked_array_event (chtype type, unsigned long count, chid chanId, caEventCallBackFunc pFunc, void pArg, ca_real p_delta, ca_real n_delta, ca_real timeout, evid *pEventID, long mask)

LIBCA_API int epicsStdCall	ca_modify_user_name (const char *pUserName)

LIBCA_API int epicsStdCall	ca_modify_host_name (const char *pHostName)

Macro Definition Documentation

#define ca_add_array_event	(	TYPE,
		COUNT,
		CHID,
		ENTRY,
		ARG,
		P_DELTA,
		N_DELTA,
		TO,
		EVID
	)	ca_add_masked_array_event(TYPE,COUNT,CHID,ENTRY,ARG,P_DELTA,N_DELTA,TO,EVID, DBE_VALUE \| DBE_ALARM)

Definition at line 872 of file cadef.h.

#define ca_add_delta_event	(	TYPE,
		CHID,
		ENTRY,
		ARG,
		DELTA,
		EVID
	)	ca_add_array_event(TYPE,1,CHID,ENTRY,ARG,DELTA,DELTA,0.0,EVID)

Definition at line 868 of file cadef.h.

#define ca_add_event	(	type,
		chan,
		pFunc,
		pArg,
		pEventID
	)	ca_add_array_event(type,1u,chan,pFunc,pArg,0.0,0.0,0.0,pEventID)

Definition at line 866 of file cadef.h.

#define ca_add_general_event	(	TYPE,
		CHID,
		ENTRY,
		ARG,
		P_DELTA,
		N_DELTA,
		TO,
		EVID
	)	ca_add_array_event(TYPE,1,CHID,ENTRY,ARG,P_DELTA,N_DELTA,TO,EVID)

Definition at line 870 of file cadef.h.

#define ca_array_build	(	NAME,
		XXXXX,
		ZZZZZZ,
		CHIDPTR,
		YYYYY
	)	ca_build_and_connect(NAME, XXXXX, ZZZZZZ, CHIDPTR, YYYYY, 0, 0)

Definition at line 854 of file cadef.h.

#define ca_bget	(	chan,
		pValue
	)	ca_array_get(DBR_STRING, 1u, chan, (dbr_string_t *)(pValue))

Definition at line 363 of file cadef.h.

#define ca_bget_callback	(	chan,
		pFunc,
		pArg
	)	ca_array_get_callback (DBR_STRING, 1u, chan, pFunc, pArg)

Definition at line 418 of file cadef.h.

#define ca_bput	(	chan,
		pValue
	)	ca_array_put(DBR_STRING, 1u, chan, (const dbr_string_t *) (pValue))

Definition at line 281 of file cadef.h.

#define ca_build_channel	(	NAME,
		XXXXX,
		CHIDPTR,
		YYYYY
	)	ca_build_and_connect(NAME, XXXXX, 1, CHIDPTR, YYYYY, 0, 0)

Definition at line 852 of file cadef.h.

#define ca_get	(	type,
		chan,
		pValue
	)	ca_array_get(type, 1u, chan, pValue)

Definition at line 384 of file cadef.h.

#define ca_get_callback	(	type,
		chan,
		pFunc,
		pArg
	)	ca_array_get_callback (type, 1u, chan, pFunc, pArg)

Definition at line 441 of file cadef.h.

#define CA_OP_ADD_EVENT 3

Definition at line 121 of file cadef.h.

#define CA_OP_CLEAR_EVENT 4

Definition at line 122 of file cadef.h.

#define CA_OP_CONN_DOWN 7

Definition at line 129 of file cadef.h.

#define CA_OP_CONN_UP 6

Definition at line 128 of file cadef.h.

#define CA_OP_CREATE_CHANNEL 2

Definition at line 120 of file cadef.h.

#define CA_OP_GET 0

Definition at line 118 of file cadef.h.

#define CA_OP_OTHER 5

Definition at line 123 of file cadef.h.

#define CA_OP_PUT 1

Definition at line 119 of file cadef.h.

#define CA_OP_SEARCH 2

Definition at line 132 of file cadef.h.

#define ca_poll ( ) ca_pend_event(1e-12)

Definition at line 564 of file cadef.h.

#define CA_PRIORITY_ARCHIVE 20

Definition at line 195 of file cadef.h.

#define CA_PRIORITY_DB_LINKS 80

Definition at line 194 of file cadef.h.

#define CA_PRIORITY_DEFAULT CA_PRIORITY_MIN

Definition at line 192 of file cadef.h.

#define CA_PRIORITY_MAX 99

Definition at line 190 of file cadef.h.

#define CA_PRIORITY_MIN 0

Definition at line 191 of file cadef.h.

#define CA_PRIORITY_OPI 0

Definition at line 196 of file cadef.h.

#define ca_put	(	type,
		chan,
		pValue
	)	ca_array_put (type, 1u, chan, pValue)

Definition at line 302 of file cadef.h.

#define ca_put_callback	(	type,
		chan,
		pValue,
		pFunc,
		pArg
	)	ca_array_put_callback(type, 1u, chan, pValue, pFunc, pArg)

Definition at line 347 of file cadef.h.

#define ca_rget	(	chan,
		pValue
	)	ca_array_get(DBR_FLOAT, 1u, chan, (dbr_float_t *)(pValue))

Definition at line 374 of file cadef.h.

#define ca_rget_callback	(	chan,
		pFunc,
		pArg
	)	ca_array_get_callback (DBR_FLOAT, 1u, chan, pFunc, pArg)

Definition at line 430 of file cadef.h.

#define ca_rput	(	chan,
		pValue
	)	ca_array_put(DBR_FLOAT, 1u, chan, (const dbr_float_t *) pValue)

Definition at line 292 of file cadef.h.

#define ca_search	(	pChanName,
		pChanID
	)	ca_search_and_connect (pChanName, pChanID, 0, 0)

Definition at line 859 of file cadef.h.

#define ca_sg_get	(	gid,
		type,
		chan,
		pValue
	)	ca_sg_array_get (gid, type, 1u, chan, pValue)

Definition at line 751 of file cadef.h.

#define ca_sg_put	(	gid,
		type,
		chan,
		pValue
	)	ca_sg_array_put (gid, type, 1u, chan, pValue)

Definition at line 775 of file cadef.h.

#define SEVCHK	(	CA_ERROR_CODE,
		MESSAGE_STRING
	)

Value:

{ \
    int ca_unique_status_name  = (CA_ERROR_CODE); \
    if(!(ca_unique_status_name & CA_M_SUCCESS)) \
        ca_signal_with_file_and_lineno( \
            ca_unique_status_name, \
            (MESSAGE_STRING), \
            __FILE__, \
            __LINE__); \
}

Definition at line 137 of file cadef.h.

#define TYPENOTCONN (-1) /* the channel's native type when disconnected */

Definition at line 149 of file cadef.h.

#define VALID_TYPE ( TYPE ) (((unsigned short)TYPE)<=LAST_BUFFER_TYPE)

Definition at line 73 of file cadef.h.

Typedef Documentation

typedef double ca_real

Definition at line 49 of file cadef.h.

typedef unsigned CA_SYNC_GID

Definition at line 113 of file cadef.h.

typedef struct ca_access_rights caar

typedef void caArh(struct access_rights_handler_args args)

Definition at line 70 of file cadef.h.

typedef void caCh(struct connection_handler_args args)

Definition at line 57 of file cadef.h.

typedef void caEventCallBackFunc(struct event_handler_args)

Definition at line 92 of file cadef.h.

typedef void caExceptionHandler(struct exception_handler_args)

Definition at line 251 of file cadef.h.

typedef void CAFDHANDLER(void *parg, int fd, int opened)

Definition at line 657 of file cadef.h.

typedef unsigned capri

Definition at line 189 of file cadef.h.

typedef int caPrintfFunc(const char *pformat, va_list args)

Definition at line 821 of file cadef.h.

typedef chid chanId

Definition at line 46 of file cadef.h.

typedef struct oldChannelNotify* chid

Definition at line 45 of file cadef.h.

typedef long chtype

Definition at line 47 of file cadef.h.

typedef struct event_handler_args evargs

typedef struct oldSubscription* evid

Definition at line 48 of file cadef.h.

Enumeration Type Documentation

enum ca_preemptive_callback_select

Enumerator
ca_disable_preemptive_callback
ca_enable_preemptive_callback

Definition at line 175 of file cadef.h.

176 { ca_disable_preemptive_callback, ca_enable_preemptive_callback };

ca_disable_preemptive_callback

Definition: cadef.h:176

ca_enable_preemptive_callback

Definition: cadef.h:176

enum channel_state

Enumerator
cs_never_conn
cs_prev_conn
cs_conn
cs_closed

Definition at line 166 of file cadef.h.

166 {cs_never_conn, cs_prev_conn, cs_conn, cs_closed};

cs_never_conn

Definition: cadef.h:166

cs_closed

Definition: cadef.h:166

cs_conn

Definition: cadef.h:166

cs_prev_conn

Definition: cadef.h:166

Function Documentation

LIBCA_API int epicsStdCall ca_add_exception_event	(	caExceptionHandler *	pfunc,
		void *	pArg
	)

Definition at line 402 of file access.cpp.

 {
     ca_client_context *pcac;
     int caStatus = fetchClientContext ( &pcac );
     if ( caStatus != ECA_NORMAL ) {
         return caStatus;
     }
 
     pcac->changeExceptionEvent ( pfunc, arg );
 
     return ECA_NORMAL;
 }

LIBCA_API int epicsStdCall ca_add_fd_registration	(	CAFDHANDLER *	pHandler,
		void *	pArg
	)

Definition at line 623 of file access.cpp.

 {
     ca_client_context *pcac;
     int caStatus = fetchClientContext ( &pcac );
     if ( caStatus != ECA_NORMAL ) {
         return caStatus;
     }
 
     pcac->registerForFileDescriptorCallBack ( func, arg );
 
     return ECA_NORMAL;
 }

LIBCA_API int epicsStdCall ca_add_masked_array_event	(	chtype	type,
		unsigned long	count,
		chid	chanId,
		caEventCallBackFunc *	pFunc,
		void *	pArg,
		ca_real	p_delta,
		ca_real	n_delta,
		ca_real	timeout,
		evid *	pEventID,
		long	mask
	)

Definition at line 418 of file access.cpp.

 {
     return ca_create_subscription ( type, count, pChan, mask,
         pCallBack, pCallBackArg, monixptr );
 }

LIBCA_API int epicsStdCall ca_array_get	(	chtype	type,
		unsigned long	count,
		chid	chanId,
		void *	pValue
	)

Definition at line 267 of file oldChannelNotify.cpp.

 {
     int caStatus;
     try {
         if ( type < 0 ) {
             return ECA_BADTYPE;
         }
         if ( count == 0 )
             return ECA_BADCOUNT;
 
         unsigned tmpType = static_cast < unsigned > ( type );
         epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
         pChan->eliminateExcessiveSendBacklog ( guard );
         autoPtrFreeList < getCopy, 0x400, epicsMutexNOOP > pNotify
             ( pChan->getClientCtx().getCopyFreeList,
                 new ( pChan->getClientCtx().getCopyFreeList )
                     getCopy ( guard, pChan->getClientCtx(), *pChan,
                                 tmpType, count, pValue ) );
         pChan->io.read ( guard, type, count, *pNotify, 0 );
         pNotify.release ();
         caStatus = ECA_NORMAL;
     }
     catch ( cacChannel::badString & )
     {
         caStatus = ECA_BADSTR;
     }
     catch ( cacChannel::badType & )
     {
         caStatus = ECA_BADTYPE;
     }
     catch ( cacChannel::outOfBounds & )
     {
         caStatus = ECA_BADCOUNT;
     }
     catch ( cacChannel::noReadAccess & )
     {
         caStatus = ECA_NORDACCESS;
     }
     catch ( cacChannel::notConnected & )
     {
         caStatus = ECA_DISCONN;
     }
     catch ( cacChannel::unsupportedByService & )
     {
         caStatus = ECA_UNAVAILINSERV;
     }
     catch ( cacChannel::requestTimedOut & )
     {
         caStatus = ECA_TIMEOUT;
     }
     catch ( std::bad_alloc & )
     {
         caStatus = ECA_ALLOCMEM;
     }
     catch ( cacChannel::msgBodyCacheTooSmall & ) {
         caStatus = ECA_TOLARGE;
     }
     catch ( ... )
     {
         caStatus = ECA_GETFAIL;
     }
     return caStatus;
 }

LIBCA_API int epicsStdCall ca_array_get_callback	(	chtype	type,
		unsigned long	count,
		chid	chanId,
		caEventCallBackFunc *	pFunc,
		void *	pArg
	)

Definition at line 335 of file oldChannelNotify.cpp.

 {
     int caStatus;
     try {
         if ( type < 0 ) {
             return ECA_BADTYPE;
         }
         if ( pfunc == NULL ) {
             return ECA_BADFUNCPTR;
         }
         unsigned tmpType = static_cast < unsigned > ( type );
 
         epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
         pChan->eliminateExcessiveSendBacklog ( guard );
         autoPtrFreeList < getCallback, 0x400, epicsMutexNOOP > pNotify
             ( pChan->getClientCtx().getCallbackFreeList,
             new ( pChan->getClientCtx().getCallbackFreeList )
                 getCallback ( *pChan, pfunc, arg ) );
         pChan->io.read ( guard, tmpType, count, *pNotify, 0 );
         pNotify.release ();
         caStatus = ECA_NORMAL;
     }
     catch ( cacChannel::badString & )
     {
         caStatus = ECA_BADSTR;
     }
     catch ( cacChannel::badType & )
     {
         caStatus = ECA_BADTYPE;
     }
     catch ( cacChannel::outOfBounds & )
     {
         caStatus = ECA_BADCOUNT;
     }
     catch ( cacChannel::noReadAccess & )
     {
         caStatus = ECA_NORDACCESS;
     }
     catch ( cacChannel::notConnected & )
     {
         caStatus = ECA_DISCONN;
     }
     catch ( cacChannel::unsupportedByService & )
     {
         caStatus = ECA_UNAVAILINSERV;
     }
     catch ( cacChannel::requestTimedOut & )
     {
         caStatus = ECA_TIMEOUT;
     }
     catch ( std::bad_alloc & )
     {
         caStatus = ECA_ALLOCMEM;
     }
     catch ( cacChannel::msgBodyCacheTooSmall & ) {
         caStatus = ECA_TOLARGE;
     }
     catch ( ... )
     {
         caStatus = ECA_GETFAIL;
     }
     return caStatus;
 }

LIBCA_API int epicsStdCall ca_array_put	(	chtype	type,
		unsigned long	count,
		chid	chanId,
		const void *	pValue
	)

Definition at line 476 of file oldChannelNotify.cpp.

 {
     if ( type < 0 ) {
         return ECA_BADTYPE;
     }
     unsigned tmpType = static_cast < unsigned > ( type );
 
     int caStatus;
     try {
         epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
         pChan->eliminateExcessiveSendBacklog ( guard );
         pChan->io.write ( guard, tmpType, count, pValue );
         caStatus = ECA_NORMAL;
     }
     catch ( cacChannel::badString & )
     {
         caStatus = ECA_BADSTR;
     }
     catch ( cacChannel::badType & )
     {
         caStatus = ECA_BADTYPE;
     }
     catch ( cacChannel::outOfBounds & )
     {
         caStatus = ECA_BADCOUNT;
     }
     catch ( cacChannel::noWriteAccess & )
     {
         caStatus = ECA_NOWTACCESS;
     }
     catch ( cacChannel::notConnected & )
     {
         caStatus = ECA_DISCONN;
     }
     catch ( cacChannel::unsupportedByService & )
     {
         caStatus = ECA_UNAVAILINSERV;
     }
     catch ( cacChannel::requestTimedOut & )
     {
         caStatus = ECA_TIMEOUT;
     }
     catch ( std::bad_alloc & )
     {
         caStatus = ECA_ALLOCMEM;
     }
     catch ( ... )
     {
         caStatus = ECA_PUTFAIL;
     }
     return caStatus;
 }

LIBCA_API int epicsStdCall ca_array_put_callback	(	chtype	type,
		unsigned long	count,
		chid	chanId,
		const void *	pValue,
		caEventCallBackFunc *	pFunc,
		void *	pArg
	)

Definition at line 412 of file oldChannelNotify.cpp.

 {
     int caStatus;
     try {
         if ( type < 0 ) {
             return ECA_BADTYPE;
         }
         if ( pfunc == NULL ) {
             return ECA_BADFUNCPTR;
         }
         epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
         pChan->eliminateExcessiveSendBacklog ( guard );
         unsigned tmpType = static_cast < unsigned > ( type );
         autoPtrFreeList < putCallback, 0x400, epicsMutexNOOP > pNotify
                 ( pChan->getClientCtx().putCallbackFreeList,
                     new ( pChan->getClientCtx().putCallbackFreeList )
                         putCallback ( *pChan, pfunc, usrarg ) );
         pChan->io.write ( guard, tmpType, count, pValue, *pNotify, 0 );
         pNotify.release ();
         caStatus = ECA_NORMAL;
     }
     catch ( cacChannel::badString & )
     {
         caStatus = ECA_BADSTR;
     }
     catch ( cacChannel::badType & )
     {
         caStatus = ECA_BADTYPE;
     }
     catch ( cacChannel::outOfBounds & )
     {
         caStatus = ECA_BADCOUNT;
     }
     catch ( cacChannel::noWriteAccess & )
     {
         caStatus = ECA_NOWTACCESS;
     }
     catch ( cacChannel::notConnected & )
     {
         caStatus = ECA_DISCONN;
     }
     catch ( cacChannel::unsupportedByService & )
     {
         caStatus = ECA_UNAVAILINSERV;
     }
     catch ( cacChannel::requestTimedOut & )
     {
         caStatus = ECA_TIMEOUT;
     }
     catch ( std::bad_alloc & )
     {
         caStatus = ECA_ALLOCMEM;
     }
     catch ( ... )
     {
         caStatus = ECA_PUTFAIL;
     }
     return caStatus;
 }

LIBCA_API int epicsStdCall ca_attach_context ( struct ca_client_context * context )

Definition at line 746 of file access.cpp.

 {
     ca_client_context *pcac = (ca_client_context *) epicsThreadPrivateGet ( caClientContextId );
     if ( pcac && pCtx != 0 ) {
         return ECA_ISATTACHED;
     }
     if ( ! pCtx->preemptiveCallbakIsEnabled() ) {
         return ECA_NOTTHREADED;
     }
     epicsThreadPrivateSet ( caClientContextId, pCtx );
     return ECA_NORMAL;
 }

LIBCA_API unsigned epicsStdCall ca_beacon_anomaly_count ( void )

Definition at line 681 of file access.cpp.

 {
     ca_client_context * pcac;
     int caStatus = fetchClientContext ( & pcac );
     if ( caStatus != ECA_NORMAL ) {
         return 0u;
     }
 
     return pcac->beaconAnomaliesSinceProgramStart ();
 }

LIBCA_API double epicsStdCall ca_beacon_period ( chid chan )

Definition at line 686 of file oldChannelNotify.cpp.

 {
     epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
     return pChan->io.beaconPeriod ( guard );
 }

LIBCA_API int epicsStdCall ca_build_and_connect	(	const char *	pChanName,
		chtype	,
		unsigned	long,
		chid *	pChanID,
		void *	,
		caCh *	pFunc,
		void *	pArg
	)

LIBCA_API int epicsStdCall ca_change_connection_event	(	chid	chan,
		caCh *	pfunc
	)

Definition at line 218 of file oldChannelNotify.cpp.

 {
     epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
     if ( ! pChan->currentlyConnected ) {
          if ( pfunc ) {
             if ( ! pChan->pConnCallBack ) {
                 pChan->cacCtx.decrementOutstandingIO ( guard, pChan->ioSeqNo );
             }
         }
         else {
             if ( pChan->pConnCallBack ) {
                 pChan->cacCtx.incrementOutstandingIO ( guard, pChan->ioSeqNo );
             }
         }
     }
     pChan->pConnCallBack = pfunc;
     return ECA_NORMAL;
 }

LIBCA_API int epicsStdCall ca_channel_status ( epicsThreadId tid )

Definition at line 693 of file access.cpp.

 {
     ::printf ("The R3.14 EPICS OS abstraction API does not allow peeking at thread private storage of another thread.\n");
     ::printf ("Please call \"ca_client_status ( unsigned level )\" from the subsystem specific diagnostic code.\n");
     return ECA_ANACHRONISM;
 }

LIBCA_API int epicsStdCall ca_clear_channel ( chid chanId )

Definition at line 363 of file access.cpp.

 {
     ca_client_context & cac = pChan->getClientCtx ();
     {
         epicsGuard < epicsMutex > guard ( cac.mutex );
         try {
             pChan->eliminateExcessiveSendBacklog ( guard );
         }
         catch ( cacChannel::notConnected & ) {
             // intentionally ignored
         }
     }
     if ( cac.pCallbackGuard.get() &&
             cac.createdByThread == epicsThreadGetIdSelf () ) {
         epicsGuard < epicsMutex > guard ( cac.mutex );
         pChan->destructor ( *cac.pCallbackGuard.get(), guard );
         cac.oldChannelNotifyFreeList.release ( pChan );
     }
     else {
         //
         // we will definately stall out here if all of the
         // following are true
         //
         // o user creates non-preemtive mode client library context
         // o user doesnt periodically call a ca function
         // o user calls this function from an auxiillary thread
         //
         CallbackGuard cbGuard ( cac.cbMutex );
         epicsGuard < epicsMutex > guard ( cac.mutex );
         pChan->destructor ( *cac.pCallbackGuard.get(), guard );
         cac.oldChannelNotifyFreeList.release ( pChan );
     }
     return ECA_NORMAL;
 }

LIBCA_API int epicsStdCall ca_clear_event ( evid eventID )

Definition at line 431 of file access.cpp.

 {
     return ca_clear_subscription ( pMon );
 }

LIBCA_API int epicsStdCall ca_clear_subscription ( evid eventID )

Definition at line 743 of file ca_client_context.cpp.

 {
     oldChannelNotify & chan = pMon->channel ();
     ca_client_context & cac = chan.getClientCtx ();
     // !!!! the order in which we take the mutex here prevents deadlocks
     {
         epicsGuard < epicsMutex > guard ( cac.mutex );
         try {
             // if this stalls out on a live circuit then an exception
             // can be forthcoming which we must ignore as the clear
             // request must always be successful
             chan.eliminateExcessiveSendBacklog ( guard );
         }
         catch ( cacChannel::notConnected & ) {
             // intentionally ignored
         }
     }
     if ( cac.pCallbackGuard.get() &&
         cac.createdByThread == epicsThreadGetIdSelf () ) {
       epicsGuard < epicsMutex > guard ( cac.mutex );
       pMon->cancel ( *cac.pCallbackGuard.get(), guard );
     }
     else {
       //
       // we will definately stall out here if all of the
       // following are true
       //
       // o user creates non-preemtive mode client library context
       // o user doesnt periodically call a ca function
       // o user calls this function from an auxiillary thread
       //
       CallbackGuard cbGuard ( cac.cbMutex );
       epicsGuard < epicsMutex > guard ( cac.mutex );
       pMon->cancel ( cbGuard, guard );
     }
     return ECA_NORMAL;
 }

LIBCA_API int epicsStdCall ca_client_status ( unsigned level )

Definition at line 701 of file access.cpp.

 {
     ca_client_context *pcac;
     int caStatus = fetchClientContext ( &pcac );
     if ( caStatus != ECA_NORMAL ) {
         return caStatus;
     }
 
     pcac->show ( level );
     return ECA_NORMAL;
 }

LIBCA_API int epicsStdCall ca_context_create ( enum ca_preemptive_callback_select select )

Definition at line 172 of file access.cpp.

 {
     ca_client_context *pcac;
 
     try {
         epicsThreadOnce ( & caClientContextIdOnce, ca_init_client_context, 0);
         if ( caClientContextId == 0 ) {
             return ECA_ALLOCMEM;
         }
 
         pcac = ( ca_client_context * ) epicsThreadPrivateGet ( caClientContextId );
         if ( pcac ) {
             if ( premptiveCallbackSelect == ca_enable_preemptive_callback &&
                 ! pcac->preemptiveCallbakIsEnabled() ) {
                 return ECA_NOTTHREADED;
             }
             return ECA_NORMAL;
         }
 
         pcac = new ca_client_context (
             premptiveCallbackSelect == ca_enable_preemptive_callback );
         if ( ! pcac ) {
             return ECA_ALLOCMEM;
         }
 
         epicsThreadPrivateSet ( caClientContextId, (void *) pcac );
     }
     catch ( ... ) {
         return ECA_ALLOCMEM;
     }
     return ECA_NORMAL;
 }

LIBCA_API void epicsStdCall ca_context_destroy ( void )

Definition at line 232 of file access.cpp.

 {
     ca_client_context   *pcac;
 
     if ( caClientContextId != NULL ) {
         pcac = (ca_client_context *) epicsThreadPrivateGet ( caClientContextId );
         if ( pcac ) {
             delete pcac;
             epicsThreadPrivateSet ( caClientContextId, 0 );
         }
     }
 }

LIBCA_API int epicsStdCall ca_context_status	(	struct ca_client_context *	,
		unsigned	level
	)

Definition at line 713 of file access.cpp.

 {
     pcac->show ( level );
     return ECA_NORMAL;
 }

LIBCA_API int epicsStdCall ca_create_channel	(	const char *	pChanName,
		caCh *	pConnStateCallback,
		void *	pUserPrivate,
		capri	priority,
		chid *	pChanID
	)

Definition at line 288 of file access.cpp.

 {
     ca_client_context * pcac;
     int caStatus = fetchClientContext ( & pcac );
     if ( caStatus != ECA_NORMAL ) {
         return caStatus;
     }
 
     {
         CAFDHANDLER * pFunc = 0;
         void * pArg = 0;
         {
             epicsGuard < epicsMutex >
                 guard ( pcac->mutex );
             if ( pcac->fdRegFuncNeedsToBeCalled ) {
                 pFunc = pcac->fdRegFunc;
                 pArg = pcac->fdRegArg;
                 pcac->fdRegFuncNeedsToBeCalled = false;
             }
         }
         if ( pFunc ) {
             ( *pFunc ) ( pArg, pcac->sock, true );
         }
     }
 
     try {
         epicsGuard < epicsMutex > guard ( pcac->mutex );
         oldChannelNotify * pChanNotify =
             new ( pcac->oldChannelNotifyFreeList )
                 oldChannelNotify ( guard, *pcac, name_str,
                     conn_func, puser, priority );
         // make sure that their chan pointer is set prior to
         // calling connection call backs
         *chanptr = pChanNotify;
         pChanNotify->initiateConnect ( guard );
         // no need to worry about a connect preempting here because
         // the connect sequence will not start untill initiateConnect()
         // is called
     }
     catch ( cacChannel::badString & ) {
         return ECA_BADSTR;
     }
     catch ( std::bad_alloc & ) {
         return ECA_ALLOCMEM;
     }
     catch ( cacChannel::badPriority & ) {
         return ECA_BADPRIORITY;
     }
     catch ( cacChannel::unsupportedByService & ) {
         return ECA_UNAVAILINSERV;
     }
     catch ( std :: exception & except ) {
         pcac->printFormated (
             "ca_create_channel: "
             "unexpected exception was \"%s\"",
             except.what () );
         return ECA_INTERNAL;
     }
     catch ( ... ) {
         return ECA_INTERNAL;
     }
 
     return ECA_NORMAL;
 }

LIBCA_API int epicsStdCall ca_create_subscription	(	chtype	type,
		unsigned long	count,
		chid	chanId,
		long	mask,
		caEventCallBackFunc *	pFunc,
		void *	pArg,
		evid *	pEventID
	)

Definition at line 530 of file oldChannelNotify.cpp.

 {
     if ( type < 0 ) {
         return ECA_BADTYPE;
     }
     unsigned tmpType = static_cast < unsigned > ( type );
 
     if ( INVALID_DB_REQ (type) ) {
         return ECA_BADTYPE;
     }
 
     if ( pCallBack == NULL ) {
         return ECA_BADFUNCPTR;
     }
 
     static const long maskMask = 0xffff;
     if ( ( mask & maskMask ) == 0) {
         return ECA_BADMASK;
     }
 
     if ( mask & ~maskMask ) {
         return ECA_BADMASK;
     }
 
     try {
         epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
         try {
             // if this stalls out on a live circuit then an exception
             // can be forthcoming which we must ignore (this is a
             // special case preserving legacy ca_create_subscription
             // behavior)
             pChan->eliminateExcessiveSendBacklog ( guard );
         }
         catch ( cacChannel::notConnected & ) {
             // intentionally ignored (its ok to subscribe when not connected)
         }
         new ( pChan->getClientCtx().subscriptionFreeList )
             oldSubscription  (
                 guard, *pChan, pChan->io, tmpType, count, mask,
                 pCallBack, pCallBackArg, monixptr );
         // dont touch object created after above new because
         // the first callback might have canceled, and therefore
         // destroyed, it
         return ECA_NORMAL;
     }
     catch ( cacChannel::badType & )
     {
         return ECA_BADTYPE;
     }
     catch ( cacChannel::outOfBounds & )
     {
         return ECA_BADCOUNT;
     }
     catch ( cacChannel::badEventSelection & )
     {
         return ECA_BADMASK;
     }
     catch ( cacChannel::noReadAccess & )
     {
         return ECA_NORDACCESS;
     }
     catch ( cacChannel::unsupportedByService & )
     {
         return ECA_UNAVAILINSERV;
     }
     catch ( std::bad_alloc & )
     {
         return ECA_ALLOCMEM;
     }
     catch ( cacChannel::msgBodyCacheTooSmall & ) {
         return ECA_TOLARGE;
     }
     catch ( ... )
     {
         return ECA_INTERNAL;
     }
 }

LIBCA_API struct ca_client_context* epicsStdCall ca_current_context ( )

Definition at line 726 of file access.cpp.

 {
     struct ca_client_context *pCtx;
     if ( caClientContextId ) {
         pCtx = ( struct ca_client_context * )
             epicsThreadPrivateGet ( caClientContextId );
     }
     else {
         pCtx = 0;
     }
     return pCtx;
 }

LIBCA_API void epicsStdCall ca_detach_context ( )

Definition at line 759 of file access.cpp.

 {
     if ( caClientContextId ) {
         epicsThreadPrivateSet ( caClientContextId, 0 );
     }
 }

LIBCA_API void epicsStdCall ca_dump_dbr	(	chtype	type,
		unsigned	count,
		const void *	pbuffer
	)

Definition at line 50 of file test_event.cpp.

 {
     unsigned i;
     char tsString[50];
 
     if ( INVALID_DB_REQ ( type ) ) {
         printf ( "bad DBR type %ld\n", type );
     }
 
     printf ( "%s\t", dbr_text[type] );
 
     switch ( type ) {
     case DBR_STRING:
     {
         dbr_string_t    *pString = (dbr_string_t *) pbuffer;
 
         for(i=0; i<count && (*pString)[0]!='\0'; i++) {
             if(count!=1 && (i%5 == 0)) printf("\n");
             printf("%s ", *pString);
             pString++;
         }
         break;
     }
     case DBR_SHORT:
     {
         dbr_short_t *pvalue = (dbr_short_t *)pbuffer;
         for (i = 0; i < count; i++,pvalue++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%d ",* (short *)pvalue);
         }
         break;
     }
     case DBR_ENUM:
     {
         dbr_enum_t *pvalue = (dbr_enum_t *)pbuffer;
         for (i = 0; i < count; i++,pvalue++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%d ",*pvalue);
         }
         break;
     }
     case DBR_FLOAT:
     {
         dbr_float_t *pvalue = (dbr_float_t *)pbuffer;
         for (i = 0; i < count; i++,pvalue++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%6.4f ",*(float *)pvalue);
         }
         break;
     }
     case DBR_CHAR:
     {
         dbr_char_t  *pvalue = (dbr_char_t *) pbuffer;
 
         for (i = 0; i < count; i++,pvalue++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%u ",*pvalue);
         }
         break;
     }
     case DBR_LONG:
     {
         dbr_long_t *pvalue = (dbr_long_t *)pbuffer;
         for (i = 0; i < count; i++,pvalue++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%d ",*pvalue);
         }
         break;
     }
     case DBR_DOUBLE:
     {
         dbr_double_t *pvalue = (dbr_double_t *)pbuffer;
         for (i = 0; i < count; i++,pvalue++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%6.4f ",(float)(*pvalue));
         }
         break;
     }
     case DBR_STS_STRING:
     case DBR_GR_STRING:
     case DBR_CTRL_STRING:
     {
         struct dbr_sts_string *pvalue
           = (struct dbr_sts_string *) pbuffer;
         printf("%2d %2d",pvalue->status,pvalue->severity);
         printf("\tValue: %s",pvalue->value);
         break;
     }
     case DBR_STS_ENUM:
     {
         struct dbr_sts_enum *pvalue
           = (struct dbr_sts_enum *)pbuffer;
         dbr_enum_t *pEnum = &pvalue->value;
         printf("%2d %2d",pvalue->status,pvalue->severity);
         if(count==1) printf("\tValue: ");
         for (i = 0; i < count; i++,pEnum++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%u ",*pEnum);
         }
         break;
     }
     case DBR_STS_SHORT:
     {
         struct dbr_sts_short *pvalue
           = (struct dbr_sts_short *)pbuffer;
         dbr_short_t *pshort = &pvalue->value;
         printf("%2d %2d",pvalue->status,pvalue->severity);
         if(count==1) printf("\tValue: ");
         for (i = 0; i < count; i++,pshort++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%u ",*pshort);
         }
         break;
     }
     case DBR_STS_FLOAT:
     {
         struct dbr_sts_float *pvalue
           = (struct dbr_sts_float *)pbuffer;
         dbr_float_t *pfloat = &pvalue->value;
         printf("%2d %2d",pvalue->status,pvalue->severity);
         if(count==1) printf("\tValue: ");
         for (i = 0; i < count; i++,pfloat++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%6.4f ",*pfloat);
         }
         break;
     }
     case DBR_STS_CHAR:
     {
         struct dbr_sts_char *pvalue
           = (struct dbr_sts_char *)pbuffer;
         dbr_char_t *pchar = &pvalue->value;
 
         printf("%2d %2d",pvalue->status,pvalue->severity);
         if(count==1) printf("\tValue: ");
         for (i = 0; i < count; i++,pchar++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%u ", *pchar);
         }
         break;
     }
     case DBR_STS_LONG:
     {
         struct dbr_sts_long *pvalue
           = (struct dbr_sts_long *)pbuffer;
         dbr_long_t *plong = &pvalue->value;
         printf("%2d %2d",pvalue->status,pvalue->severity);
         if(count==1) printf("\tValue: ");
         for (i = 0; i < count; i++,plong++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%d ",*plong);
         }
         break;
     }
     case DBR_STS_DOUBLE:
     {
         struct dbr_sts_double *pvalue
           = (struct dbr_sts_double *)pbuffer;
         dbr_double_t *pdouble = &pvalue->value;
         printf("%2d %2d",pvalue->status,pvalue->severity);
         if(count==1) printf("\tValue: ");
         for (i = 0; i < count; i++,pdouble++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%6.4f ",(float)(*pdouble));
         }
         break;
     }
     case DBR_TIME_STRING:
     {
         struct dbr_time_string *pvalue
           = (struct dbr_time_string *) pbuffer;
 
                 epicsTimeToStrftime(tsString,sizeof(tsString),
                     "%Y/%m/%d %H:%M:%S.%06f",&pvalue->stamp);
         printf("%2d %2d",pvalue->status,pvalue->severity);
         printf("\tTimeStamp: %s",tsString);
         printf("\tValue: ");
         printf("%s",pvalue->value);
         break;
     }
     case DBR_TIME_ENUM:
     {
         struct dbr_time_enum *pvalue
           = (struct dbr_time_enum *)pbuffer;
         dbr_enum_t *pshort = &pvalue->value;
 
                 epicsTimeToStrftime(tsString,sizeof(tsString),
                     "%Y/%m/%d %H:%M:%S.%06f",&pvalue->stamp);
         printf("%2d %2d",pvalue->status,pvalue->severity);
         printf("\tTimeStamp: %s",tsString);
         if(count==1) printf("\tValue: ");
         for (i = 0; i < count; i++,pshort++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%d ",*pshort);
         }
         break;
     }
     case DBR_TIME_SHORT:
     {
         struct dbr_time_short *pvalue
           = (struct dbr_time_short *)pbuffer;
         dbr_short_t *pshort = &pvalue->value;
         epicsTimeToStrftime(tsString,sizeof(tsString),
             "%Y/%m/%d %H:%M:%S.%06f",&pvalue->stamp);
         printf("%2d %2d",
             pvalue->status,
             pvalue->severity);
         printf("\tTimeStamp: %s",tsString);
         if(count==1) printf("\tValue: ");
         for (i = 0; i < count; i++,pshort++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%d ",*pshort);
         }
         break;
     }
     case DBR_TIME_FLOAT:
     {
         struct dbr_time_float *pvalue
           = (struct dbr_time_float *)pbuffer;
         dbr_float_t *pfloat = &pvalue->value;
 
                 epicsTimeToStrftime(tsString,sizeof(tsString),
                     "%Y/%m/%d %H:%M:%S.%06f",&pvalue->stamp);
         printf("%2d %2d",pvalue->status,pvalue->severity);
         printf("\tTimeStamp: %s",tsString);
         if(count==1) printf("\tValue: ");
         for (i = 0; i < count; i++,pfloat++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%6.4f ",*pfloat);
         }
         break;
     }
     case DBR_TIME_CHAR:
     {
         struct dbr_time_char *pvalue
           = (struct dbr_time_char *)pbuffer;
         dbr_char_t *pchar = &pvalue->value;
 
                 epicsTimeToStrftime(tsString,sizeof(tsString),
                     "%Y/%m/%d %H:%M:%S.%06f",&pvalue->stamp);
         printf("%2d %2d",pvalue->status,pvalue->severity);
         printf("\tTimeStamp: %s",tsString);
         if(count==1) printf("\tValue: ");
         for (i = 0; i < count; i++,pchar++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%d ",(short)(*pchar));
         }
         break;
     }
     case DBR_TIME_LONG:
     {
         struct dbr_time_long *pvalue
           = (struct dbr_time_long *)pbuffer;
         dbr_long_t *plong = &pvalue->value;
 
                 epicsTimeToStrftime(tsString,sizeof(tsString),
                     "%Y/%m/%d %H:%M:%S.%06f",&pvalue->stamp);
         printf("%2d %2d",pvalue->status,pvalue->severity);
         printf("\tTimeStamp: %s",tsString);
         if(count==1) printf("\tValue: ");
         for (i = 0; i < count; i++,plong++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%d ",*plong);
         }
         break;
     }
     case DBR_TIME_DOUBLE:
     {
         struct dbr_time_double *pvalue
           = (struct dbr_time_double *)pbuffer;
         dbr_double_t *pdouble = &pvalue->value;
 
                 epicsTimeToStrftime(tsString,sizeof(tsString),
                     "%Y/%m/%d %H:%M:%S.%06f",&pvalue->stamp);
         printf("%2d %2d",pvalue->status,pvalue->severity);
         printf("\tTimeStamp: %s",tsString);
         if(count==1) printf("\tValue: ");
         for (i = 0; i < count; i++,pdouble++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%6.4f ",(float)(*pdouble));
         }
         break;
     }
     case DBR_GR_SHORT:
     {
         struct dbr_gr_short *pvalue
           = (struct dbr_gr_short *)pbuffer;
         dbr_short_t *pshort = &pvalue->value;
         printf("%2d %2d %.8s",pvalue->status,pvalue->severity,
             pvalue->units);
         printf("\n\t%8d %8d %8d %8d %8d %8d",
           pvalue->upper_disp_limit,pvalue->lower_disp_limit,
           pvalue->upper_alarm_limit,pvalue->upper_warning_limit,
           pvalue->lower_warning_limit,pvalue->lower_alarm_limit);
         if(count==1) printf("\tValue: ");
         for (i = 0; i < count; i++,pshort++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%d ",*pshort);
         }
         break;
     }
     case DBR_GR_FLOAT:
     {
         struct dbr_gr_float *pvalue
           = (struct dbr_gr_float *)pbuffer;
         dbr_float_t *pfloat = &pvalue->value;
         printf("%2d %2d %.8s",pvalue->status,pvalue->severity,
             pvalue->units);
         printf(" %3d\n\t%8.3f %8.3f %8.3f %8.3f %8.3f %8.3f",
           pvalue->precision,
           pvalue->upper_disp_limit,pvalue->lower_disp_limit,
           pvalue->upper_alarm_limit,pvalue->upper_warning_limit,
           pvalue->lower_warning_limit,pvalue->lower_alarm_limit);
         if(count==1) printf("\tValue: ");
         for (i = 0; i < count; i++,pfloat++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%6.4f ",*pfloat);
         }
         break;
     }
     case DBR_GR_ENUM:
     {
         struct dbr_gr_enum *pvalue
           = (struct dbr_gr_enum *)pbuffer;
         printf("%2d %2d",pvalue->status,
             pvalue->severity);
         printf("\tValue: %d",pvalue->value);
         if(pvalue->no_str>0) {
             printf("\n\t%3d",pvalue->no_str);
             for (i = 0; i < (unsigned) pvalue->no_str; i++)
                 printf("\n\t%.26s",pvalue->strs[i]);
         }
         break;
     }
     case DBR_CTRL_ENUM:
     {
         struct dbr_ctrl_enum *pvalue
           = (struct dbr_ctrl_enum *)pbuffer;
         printf("%2d %2d",pvalue->status,
             pvalue->severity);
         printf("\tValue: %d",pvalue->value);
         if(pvalue->no_str>0) {
             printf("\n\t%3d",pvalue->no_str);
             for (i = 0; i < (unsigned) pvalue->no_str; i++)
                 printf("\n\t%.26s",pvalue->strs[i]);
         }
         break;
     }
     case DBR_GR_CHAR:
     {
         struct dbr_gr_char *pvalue
           = (struct dbr_gr_char *)pbuffer;
         dbr_char_t *pchar = &pvalue->value;
         printf("%2d %2d %.8s",pvalue->status,pvalue->severity,
             pvalue->units);
         printf("\n\t%8d %8d %8d %8d %8d %8d",
           pvalue->upper_disp_limit,pvalue->lower_disp_limit,
           pvalue->upper_alarm_limit,pvalue->upper_warning_limit,
           pvalue->lower_warning_limit,pvalue->lower_alarm_limit);
         if(count==1) printf("\tValue: ");
         for (i = 0; i < count; i++,pchar++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%u ",*pchar);
         }
         break;
     }
     case DBR_GR_LONG:
     {
         struct dbr_gr_long *pvalue
           = (struct dbr_gr_long *)pbuffer;
         dbr_long_t *plong = &pvalue->value;
         printf("%2d %2d %.8s",pvalue->status,pvalue->severity,
             pvalue->units);
         printf("\n\t%8d %8d %8d %8d %8d %8d",
           pvalue->upper_disp_limit,pvalue->lower_disp_limit,
           pvalue->upper_alarm_limit,pvalue->upper_warning_limit,
           pvalue->lower_warning_limit,pvalue->lower_alarm_limit);
         if(count==1) printf("\tValue: ");
         for (i = 0; i < count; i++,plong++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%d ",*plong);
         }
         break;
     }
     case DBR_GR_DOUBLE:
     {
         struct dbr_gr_double *pvalue
           = (struct dbr_gr_double *)pbuffer;
         dbr_double_t *pdouble = &pvalue->value;
         printf("%2d %2d %.8s",pvalue->status,pvalue->severity,
             pvalue->units);
         printf(" %3d\n\t%8.3f %8.3f %8.3f %8.3f %8.3f %8.3f",
           pvalue->precision,
           (float)(pvalue->upper_disp_limit),
           (float)(pvalue->lower_disp_limit),
           (float)(pvalue->upper_alarm_limit),
           (float)(pvalue->upper_warning_limit),
           (float)(pvalue->lower_warning_limit),
           (float)(pvalue->lower_alarm_limit));
         if(count==1) printf("\tValue: ");
         for (i = 0; i < count; i++,pdouble++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%6.4f ",(float)(*pdouble));
         }
         break;
     }
     case DBR_CTRL_SHORT:
     {
         struct dbr_ctrl_short *pvalue
           = (struct dbr_ctrl_short *)pbuffer;
         dbr_short_t *pshort = &pvalue->value;
         printf("%2d %2d %.8s",pvalue->status,pvalue->severity,
             pvalue->units);
         printf("\n\t%8d %8d %8d %8d %8d %8d",
           pvalue->upper_disp_limit,pvalue->lower_disp_limit,
           pvalue->upper_alarm_limit,pvalue->upper_warning_limit,
           pvalue->lower_warning_limit,pvalue->lower_alarm_limit);
         printf(" %8d %8d",
           pvalue->upper_ctrl_limit,pvalue->lower_ctrl_limit);
         if(count==1) printf("\tValue: ");
         for (i = 0; i < count; i++,pshort++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%d ",*pshort);
         }
         break;
     }
     case DBR_CTRL_FLOAT:
     {
         struct dbr_ctrl_float *pvalue
           = (struct dbr_ctrl_float *)pbuffer;
         dbr_float_t *pfloat = &pvalue->value;
         printf("%2d %2d %.8s",pvalue->status,pvalue->severity,
             pvalue->units);
         printf(" %3d\n\t%8.3f %8.3f %8.3f %8.3f %8.3f %8.3f",
           pvalue->precision,
           pvalue->upper_disp_limit,pvalue->lower_disp_limit,
           pvalue->upper_alarm_limit,pvalue->upper_warning_limit,
           pvalue->lower_warning_limit,pvalue->lower_alarm_limit);
         printf(" %8.3f %8.3f",
           pvalue->upper_ctrl_limit,pvalue->lower_ctrl_limit);
         if(count==1) printf("\tValue: ");
         for (i = 0; i < count; i++,pfloat++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%6.4f ",*pfloat);
         }
         break;
     }
     case DBR_CTRL_CHAR:
     {
         struct dbr_ctrl_char *pvalue
           = (struct dbr_ctrl_char *)pbuffer;
         dbr_char_t *pchar = &pvalue->value;
         printf("%2d %2d %.8s",pvalue->status,pvalue->severity,
             pvalue->units);
         printf("\n\t%8d %8d %8d %8d %8d %8d",
           pvalue->upper_disp_limit,pvalue->lower_disp_limit,
           pvalue->upper_alarm_limit,pvalue->upper_warning_limit,
           pvalue->lower_warning_limit,pvalue->lower_alarm_limit);
         printf(" %8d %8d",
           pvalue->upper_ctrl_limit,pvalue->lower_ctrl_limit);
         if(count==1) printf("\tValue: ");
         for (i = 0; i < count; i++,pchar++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%4d ",(short)(*pchar));
         }
         break;
     }
     case DBR_CTRL_LONG:
     {
         struct dbr_ctrl_long *pvalue
           = (struct dbr_ctrl_long *)pbuffer;
         dbr_long_t *plong = &pvalue->value;
         printf("%2d %2d %.8s",pvalue->status,pvalue->severity,
             pvalue->units);
         printf("\n\t%8d %8d %8d %8d %8d %8d",
           pvalue->upper_disp_limit,pvalue->lower_disp_limit,
           pvalue->upper_alarm_limit,pvalue->upper_warning_limit,
           pvalue->lower_warning_limit,pvalue->lower_alarm_limit);
         printf(" %8d %8d",
           pvalue->upper_ctrl_limit,pvalue->lower_ctrl_limit);
         if(count==1) printf("\tValue: ");
         for (i = 0; i < count; i++,plong++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%d ",*plong);
         }
         break;
     }
     case DBR_CTRL_DOUBLE:
     {
         struct dbr_ctrl_double *pvalue
           = (struct dbr_ctrl_double *)pbuffer;
         dbr_double_t *pdouble = &pvalue->value;
         printf("%2d %2d %.8s",pvalue->status,pvalue->severity,
             pvalue->units);
         printf(" %3d\n\t%8.3f %8.3f %8.3f %8.3f %8.3f %8.3f",
           pvalue->precision,
           (float)(pvalue->upper_disp_limit),
           (float)(pvalue->lower_disp_limit),
           (float)(pvalue->upper_alarm_limit),
           (float)(pvalue->upper_warning_limit),
           (float)(pvalue->lower_warning_limit),
           (float)(pvalue->lower_alarm_limit));
         printf(" %8.3f %8.3f",
           (float)(pvalue->upper_ctrl_limit),
           (float)(pvalue->lower_ctrl_limit));
         if(count==1) printf("\tValue: ");
         for (i = 0; i < count; i++,pdouble++){
             if(count!=1 && (i%10 == 0)) printf("\n");
             printf("%6.6f ",(float)(*pdouble));
         }
         break;
     }
     case DBR_STSACK_STRING:
     {
         struct dbr_stsack_string *pvalue
           = (struct dbr_stsack_string *)pbuffer;
         printf("%2d %2d",pvalue->status,pvalue->severity);
         printf(" %2d %2d",pvalue->ackt,pvalue->acks);
         printf(" %s",pvalue->value);
         break;
     }
     case DBR_CLASS_NAME:
     {
         dbr_class_name_t * pvalue =
             ( dbr_class_name_t * ) pbuffer;
         printf ( "%s", *pvalue );
         break;
     }
     default:
         printf (
             "unsupported by ca_dbrDump()" );
         break;
     }
     printf("\n");
 }

LIBCA_API unsigned long epicsStdCall ca_element_count ( chid chan )

Definition at line 630 of file oldChannelNotify.cpp.

 {
     epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
     return pChan->io.nativeElementCount ( guard );
 }

LIBCA_API chid epicsStdCall ca_evid_to_chid ( evid id )

Definition at line 437 of file access.cpp.

 {
     return & pMon->channel ();
 }

LIBCA_API short epicsStdCall ca_field_type ( chid chan )

Definition at line 621 of file oldChannelNotify.cpp.

 {
     epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
     return pChan->io.nativeType ( guard );
 }

LIBCA_API int epicsStdCall ca_flush_io ( void )

Definition at line 509 of file access.cpp.

 {
     ca_client_context * pcac;
     int caStatus = fetchClientContext (&pcac);
     if ( caStatus != ECA_NORMAL ) {
         return caStatus;
     }
 
     epicsGuard < epicsMutex > guard ( pcac->mutex );
     pcac->flush ( guard );
 
     return ECA_NORMAL;
 }

LIBCA_API unsigned epicsStdCall ca_get_host_name	(	chid	pChan,
		char *	pBuf,
		unsigned	bufLength
	)

Definition at line 175 of file oldChannelNotify.cpp.

 {
     epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef() );
     return pChan->io.getHostName ( guard, pBuf, bufLength );
 }

LIBCA_API unsigned epicsStdCall ca_get_ioc_connection_count ( void )

Definition at line 670 of file access.cpp.

 {
     ca_client_context * pcac;
     int caStatus = fetchClientContext ( & pcac );
     if ( caStatus != ECA_NORMAL ) {
         return 0u;
     }
 
     return pcac->circuitCount ();
 }

LIBCA_API const char* epicsStdCall ca_host_name ( chid channel )

Definition at line 188 of file oldChannelNotify.cpp.

 {
     epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
     return pChan->io.pHostName ( guard );
 }

LIBCA_API int epicsStdCall ca_modify_host_name ( const char * pHostName )

Definition at line 212 of file access.cpp.

 {
     return ECA_NORMAL;
 }

LIBCA_API int epicsStdCall ca_modify_user_name ( const char * pUserName )

Definition at line 223 of file access.cpp.

 {
     return ECA_NORMAL;
 }

LIBCA_API const char* epicsStdCall ca_name ( chid chan )

Definition at line 674 of file oldChannelNotify.cpp.

 {
     epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
     return pChan->io.pName ( guard );
 }

LIBCA_API int epicsStdCall ca_pend	(	ca_real	timeout,
		int	early
	)

Definition at line 443 of file access.cpp.

 {
     if ( early ) {
         return ca_pend_io ( timeout );
     }
     else {
         return ca_pend_event ( timeout );
     }
 }

LIBCA_API int epicsStdCall ca_pend_event ( ca_real timeOut )

Definition at line 457 of file access.cpp.

 {
     ca_client_context *pcac;
     int status = fetchClientContext ( &pcac );
     if ( status != ECA_NORMAL ) {
         return status;
     }
 
     try {
         // preserve past odd ball behavior of waiting forever when
         // the delay is zero
         if ( timeout == 0.0 ) {
             while ( true ) {
                 pcac->pendEvent ( 60.0 );
             }
         }
         return pcac->pendEvent ( timeout );
     }
     catch ( ... ) {
         return ECA_INTERNAL;
     }
 }

LIBCA_API int epicsStdCall ca_pend_io ( ca_real timeOut )

Definition at line 484 of file access.cpp.

 {
     ca_client_context *pcac;
     int status = fetchClientContext ( &pcac );
     if ( status != ECA_NORMAL ) {
         return status;
     }
 
     try {
         // preserve past odd ball behavior of waiting forever when
         // the delay is zero
         if ( timeout == 0.0 ) {
             return pcac->pendIO ( DBL_MAX );
         }
 
         return pcac->pendIO ( timeout );
     }
     catch ( ... ) {
         return ECA_INTERNAL;
     }
 }

LIBCA_API int epicsStdCall ca_preemtive_callback_is_enabled ( void )

Definition at line 766 of file access.cpp.

 {
     ca_client_context *pcac = (ca_client_context *) epicsThreadPrivateGet ( caClientContextId );
     if ( ! pcac ) {
         return 0;
     }
     return pcac->preemptiveCallbakIsEnabled ();
 }

LIBCA_API void* epicsStdCall ca_puser ( chid chan )

Definition at line 208 of file oldChannelNotify.cpp.

 {
     epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
     return pChan->pPrivate;
 }

LIBCA_API unsigned epicsStdCall ca_read_access ( chid chan )

Definition at line 656 of file oldChannelNotify.cpp.

 {
     epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
     return pChan->io.accessRights(guard).readPermit();
 }

LIBCA_API double epicsStdCall ca_receive_watchdog_delay ( chid chan )

Definition at line 692 of file oldChannelNotify.cpp.

 {
     epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
     return pChan->io.receiveWatchdogDelay ( guard );
 }

LIBCA_API int epicsStdCall ca_replace_access_rights_event	(	chid	chan,
		caArh *	pfunc
	)

Definition at line 240 of file oldChannelNotify.cpp.

 {
     epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
 
     // The order of the following is significant to guarantee that the
     // access rights handler is always gets called even if the channel connects
     // while this is running. There is some very small chance that the
     // handler could be called twice here with the same access rights state, but
     // that will not upset the application.
     pChan->pAccessRightsFunc = pfunc ? pfunc : cacNoopAccesRightsHandler;
     caAccessRights tmp = pChan->io.accessRights ( guard );
 
     if ( pChan->currentlyConnected ) {
         struct access_rights_handler_args args;
         args.chid = pChan;
         args.ar.read_access = tmp.readPermit ();
         args.ar.write_access = tmp.writePermit ();
         epicsGuardRelease < epicsMutex > unguard ( guard );
         ( *pChan->pAccessRightsFunc ) ( args );
     }
     return ECA_NORMAL;
 }

LIBCA_API int epicsStdCall ca_replace_printf_handler ( caPrintfFunc * ca_printf_func )

Definition at line 650 of file access.cpp.

 {
     ca_client_context *pcac;
     int caStatus = fetchClientContext (&pcac);
     if ( caStatus != ECA_NORMAL ) {
         return caStatus;
     }
 
     pcac->replaceErrLogHandler ( ca_printf_func );
 
     return ECA_NORMAL;
 }

LIBCA_API int epicsStdCall ca_search_and_connect	(	const char *	pChanName,
		chid *	pChanID,
		caCh *	pFunc,
		void *	pArg
	)

Definition at line 279 of file access.cpp.

 {
     return ca_create_channel ( name_str, conn_func,
         puser, CA_PRIORITY_DEFAULT, chanptr );
 }

LIBCA_API unsigned epicsStdCall ca_search_attempts ( chid chan )

Definition at line 680 of file oldChannelNotify.cpp.

 {
     epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
     return pChan->io.searchAttempts ( guard );
 }

LIBCA_API void epicsStdCall ca_self_test ( void )

Definition at line 777 of file access.cpp.

 {
     ca_client_context *pcac = (ca_client_context *) epicsThreadPrivateGet ( caClientContextId );
     if ( ! pcac ) {
         return;
     }
     pcac->selfTest ();
 }

LIBCA_API void epicsStdCall ca_set_puser	(	chid	chan,
		void *	puser
	)

Definition at line 198 of file oldChannelNotify.cpp.

 {
     epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
     pChan->pPrivate = puser;
 }

LIBCA_API int epicsStdCall ca_sg_array_get	(	const CA_SYNC_GID	gid,
		chtype	type,
		unsigned long	count,
		chid	chan,
		void *	pValue
	)

Definition at line 308 of file syncgrp.cpp.

 {
     ca_client_context *pcac;
 
     int caStatus = fetchClientContext ( &pcac );
     if ( caStatus != ECA_NORMAL ) {
         return caStatus;
     }
 
     epicsGuard < epicsMutex > guard ( pcac->mutexRef() );
     CASG * const pcasg = pcac->lookupCASG ( guard, gid );
     if ( ! pcasg ) {
         return ECA_BADSYNCGRP;
     }
 
     try {
         pcasg->get ( guard, pChan, type,
             static_cast < unsigned > ( count ), pValue );
         return ECA_NORMAL;
     }
     catch ( cacChannel::badString & )
     {
         return ECA_BADSTR;
     }
     catch ( cacChannel::badType & )
     {
         return ECA_BADTYPE;
     }
     catch ( cacChannel::outOfBounds & )
     {
         return ECA_BADCOUNT;
     }
     catch ( cacChannel::noReadAccess & )
     {
         return ECA_NORDACCESS;
     }
     catch ( cacChannel::notConnected & )
     {
         return ECA_DISCONN;
     }
     catch ( cacChannel::unsupportedByService & )
     {
         return ECA_UNAVAILINSERV;
     }
     catch ( std::bad_alloc & )
     {
         return ECA_ALLOCMEM;
     }
     catch ( ... )
     {
         return ECA_INTERNAL;
     }
 }

LIBCA_API int epicsStdCall ca_sg_array_put	(	const CA_SYNC_GID	gid,
		chtype	type,
		unsigned long	count,
		chid	chan,
		const void *	pValue
	)

Definition at line 246 of file syncgrp.cpp.

 {
     ca_client_context *pcac;
 
     int caStatus = fetchClientContext ( &pcac );
     if ( caStatus != ECA_NORMAL ) {
         return caStatus;
     }
 
     epicsGuard < epicsMutex > guard ( pcac->mutexRef() );
     CASG * const pcasg = pcac->lookupCASG ( guard, gid );
     if ( ! pcasg ) {
         return ECA_BADSYNCGRP;
     }
 
     try {
         pcasg->put ( guard, pChan, type,
             static_cast < unsigned > ( count ), pValue );
         return ECA_NORMAL;
     }
     catch ( cacChannel::badString & )
     {
         return ECA_BADSTR;
     }
     catch ( cacChannel::badType & )
     {
         return ECA_BADTYPE;
     }
     catch ( cacChannel::outOfBounds & )
     {
         return ECA_BADCOUNT;
     }
     catch ( cacChannel::noWriteAccess & )
     {
         return ECA_NOWTACCESS;
     }
     catch ( cacChannel::notConnected & )
     {
         return ECA_DISCONN;
     }
     catch ( cacChannel::unsupportedByService & )
     {
         return ECA_UNAVAILINSERV;
     }
     catch ( cacChannel::requestTimedOut & )
     {
         return ECA_TIMEOUT;
     }
     catch ( std::bad_alloc & )
     {
         return ECA_ALLOCMEM;
     }
     catch ( ... )
     {
         return ECA_INTERNAL;
     }
 }

LIBCA_API int epicsStdCall ca_sg_block	(	const CA_SYNC_GID	gid,
		ca_real	timeout
	)

Definition at line 127 of file syncgrp.cpp.

 {
     ca_client_context *pcac;
     int status = fetchClientContext ( &pcac );
     if ( status == ECA_NORMAL ) {
         CASG * pcasg;
         {
             epicsGuard < epicsMutex > guard ( pcac->mutex );
             pcasg = pcac->lookupCASG ( guard, gid );
             if ( pcasg ) {
                 status = pcasg->block (
                     pcac->pCallbackGuard.get (), guard, timeout );
             }
             else {
                 status = ECA_BADSYNCGRP;
             }
         }
         if ( pcasg ) {
             sync_group_reset ( *pcac, *pcasg );
         }
     }
     return status;
 }

LIBCA_API int epicsStdCall ca_sg_create ( CA_SYNC_GID * pgid )

Definition at line 24 of file syncgrp.cpp.

 {
     ca_client_context * pcac;
     int caStatus;
     CASG * pcasg;
 
     caStatus = fetchClientContext ( &pcac );
     if ( caStatus != ECA_NORMAL ) {
         return caStatus;
     }
 
     try {
         epicsGuard < epicsMutex > guard ( pcac->mutexRef() );
         pcasg = new ( pcac->casgFreeList ) CASG ( guard, *pcac );
         *pgid = pcasg->getId ();
         return ECA_NORMAL;
     }
     catch ( std::bad_alloc & ) {
         return ECA_ALLOCMEM;
     }
     catch ( ... ) {
         return ECA_INTERNAL;
     }
 }

LIBCA_API int epicsStdCall ca_sg_delete ( const CA_SYNC_GID gid )

Definition at line 68 of file syncgrp.cpp.

 {
     ca_client_context * pcac;
     int caStatus = fetchClientContext ( & pcac );
     if ( caStatus == ECA_NORMAL ) {
         if ( pcac->pCallbackGuard.get() &&
             pcac->createdByThread == epicsThreadGetIdSelf () ) {
           epicsGuard < epicsMutex > guard ( pcac->mutex );
           caStatus = ca_sync_group_destroy ( *pcac->pCallbackGuard.get(),
                                           guard, *pcac, gid );
         }
         else {
           //
           // we will definately stall out here if all of the
           // following are true
           //
           // o user creates non-preemtive mode client library context
           // o user doesnt periodically call a ca function
           // o user calls this function from an auxiillary thread
           //
           CallbackGuard cbGuard ( pcac->cbMutex );
           epicsGuard < epicsMutex > guard ( pcac->mutex );
           caStatus = ca_sync_group_destroy ( cbGuard, guard, *pcac, gid );
         }
     }
     return caStatus;
 }

LIBCA_API int epicsStdCall ca_sg_reset ( const CA_SYNC_GID gid )

Definition at line 155 of file syncgrp.cpp.

 {
     ca_client_context *pcac;
     int caStatus = fetchClientContext (&pcac);
     if ( caStatus == ECA_NORMAL ) {
         CASG * pcasg;
         {
             epicsGuard < epicsMutex > guard ( pcac->mutex );
             pcasg = pcac->lookupCASG ( guard, gid );
         }
         if ( pcasg ) {
             sync_group_reset ( *pcac, *pcasg );
             caStatus = ECA_NORMAL;
         }
         else {
             caStatus = ECA_BADSYNCGRP;
         }
     }
     return caStatus;
 }

LIBCA_API int epicsStdCall ca_sg_stat ( CA_SYNC_GID gid )

Definition at line 179 of file syncgrp.cpp.

 {
     ca_client_context * pcac;
     int caStatus = fetchClientContext ( &pcac );
     if ( caStatus != ECA_NORMAL ) {
         return caStatus;
     }
 
     epicsGuard < epicsMutex > guard ( pcac->mutexRef() );
 
     CASG * pcasg = pcac->lookupCASG ( guard, gid );
     if ( ! pcasg ) {
         ::printf ( "Bad Sync Group Id\n");
         return ECA_BADSYNCGRP;
     }
     pcasg->show ( guard, 1000u );
 
     return ECA_NORMAL;
 }

LIBCA_API int epicsStdCall ca_sg_test ( const CA_SYNC_GID gid )

Definition at line 202 of file syncgrp.cpp.

 {
     ca_client_context * pcac;
     int caStatus = fetchClientContext ( &pcac );
     if ( caStatus == ECA_NORMAL ) {
         epicsGuard < epicsMutex > guard ( pcac->mutexRef() );
         CASG * pcasg = pcac->lookupCASG ( guard, gid );
         if ( pcasg ) {
             bool isComplete;
             if ( pcac->pCallbackGuard.get() &&
                 pcac->createdByThread == epicsThreadGetIdSelf () ) {
               epicsGuard < epicsMutex > guard ( pcac->mutex );
               isComplete = pcasg->ioComplete ( *pcac->pCallbackGuard.get(), guard );
             }
             else {
               //
               // we will definately stall out here if all of the
               // following are true
               //
               // o user creates non-preemtive mode client library context
               // o user doesnt periodically call a ca function
               // o user calls this function from an auxiillary thread
               //
               CallbackGuard cbGuard ( pcac->cbMutex );
               epicsGuard < epicsMutex > guard ( pcac->mutex );
               isComplete = pcasg->ioComplete ( cbGuard, guard );
             }
             if ( isComplete ) {
                 caStatus = ECA_IODONE;
             }
             else{
                 caStatus = ECA_IOINPROGRESS;
             }
         }
         else {
             caStatus = ECA_BADSYNCGRP;
         }
     }
     return caStatus;
 }

LIBCA_API void epicsStdCall ca_signal	(	long	errorCode,
		const char *	pCtxStr
	)

Definition at line 546 of file access.cpp.

 {
     ca_signal_with_file_and_lineno ( ca_status, message, NULL, 0 );
 }

LIBCA_API void epicsStdCall ca_signal_formated	(	long	ca_status,
		const char *	pfilenm,
		int	lineno,
		const char *	pFormat,
			...
	)

Definition at line 587 of file access.cpp.

 {
     ca_client_context *pcac;
 
     if ( caClientContextId ) {
         pcac = ( ca_client_context * ) epicsThreadPrivateGet ( caClientContextId );
     }
     else {
         pcac = 0;
     }
 
     va_list theArgs;
     va_start ( theArgs, pFormat );
     if ( pcac ) {
         pcac->vSignal ( ca_status, pfilenm, lineno, pFormat, theArgs );
     }
     else {
         fprintf ( stderr, "CA exception in thread w/o CA ctx: status=%s file=%s line=%d: \n",
             ca_message ( ca_status ), pfilenm, lineno );
         if ( pFormat ) {
             vfprintf ( stderr, pFormat, theArgs );
         }
     }
     va_end ( theArgs );
 }

LIBCA_API void epicsStdCall ca_signal_with_file_and_lineno	(	long	errorCode,
		const char *	pCtxStr,
		const char *	pFileStr,
		int	lineNo
	)

Definition at line 577 of file access.cpp.

 {
     ca_signal_formated ( ca_status, pfilenm, lineno, message );
 }

LIBCA_API enum channel_state epicsStdCall ca_state ( chid chan )

Definition at line 639 of file oldChannelNotify.cpp.

 {
     epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
     if ( pChan->io.connected ( guard ) ) {
         return cs_conn;
     }
     else if ( pChan->prevConnected ){
         return cs_prev_conn;
     }
     else {
         return cs_never_conn;
     }
 }

LIBCA_API int epicsStdCall ca_task_exit ( void )

Definition at line 251 of file access.cpp.

 {
     ca_context_destroy ();
     return ECA_NORMAL;
 }

LIBCA_API int epicsStdCall ca_task_initialize ( void )

Definition at line 166 of file access.cpp.

 {
     return ca_context_create ( ca_disable_preemptive_callback );
 }

LIBCA_API void epicsStdCall ca_test_event ( struct event_handler_args )

Definition at line 20 of file test_event.cpp.

 {
     chtype nativeType = ca_field_type ( args.chid );
     const char * pNativeTypeName = "<invalid>";
     if ( VALID_DB_REQ ( nativeType ) ) {
         pNativeTypeName = dbr_text[nativeType];
     }
     else {
         if ( nativeType == TYPENOTCONN ) {
             pNativeTypeName = "<disconnected>";
         }
     }
 
     printf ( "ca_test_event() for channel \"%s\" with native type %s\n",
         ca_name(args.chid), pNativeTypeName );
 
     if ( ! ( CA_M_SUCCESS & args.status ) ) {
         printf ( "Invalid CA status \"%s\"\n", ca_message ( args.status ) );
         return;
     }
 
     if ( args.dbr ) {
         ca_dump_dbr ( args.type, args.count, args.dbr );
     }
 }

LIBCA_API int epicsStdCall ca_test_io ( void )

Definition at line 526 of file access.cpp.

 {
     ca_client_context *pcac;
     int caStatus = fetchClientContext ( &pcac );
     if ( caStatus != ECA_NORMAL ) {
         return caStatus;
     }
 
     if ( pcac->ioComplete () ) {
         return ECA_IODONE;
     }
     else{
         return ECA_IOINPROGRESS;
     }
 }

LIBCA_API int epicsStdCall ca_v42_ok ( chid chan )

Definition at line 701 of file oldChannelNotify.cpp.

 {
     epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
     return pChan->io.ca_v42_ok ( guard );
 }

LIBCA_API const char* epicsStdCall ca_version ( void )

Definition at line 641 of file access.cpp.

 {
     return CA_VERSION_STRING ( CA_MINOR_PROTOCOL_REVISION );
 }

LIBCA_API unsigned epicsStdCall ca_write_access ( chid chan )

Definition at line 665 of file oldChannelNotify.cpp.

 {
     epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
     return pChan->io.accessRights(guard).writePermit();
 }

Classes

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation