oldChannelNotify Struct Reference

#include "oldAccess.h"

Inheritance diagram for oldChannelNotify:

Collaboration diagram for oldChannelNotify:

Public Member Functions
	oldChannelNotify (epicsGuard< epicsMutex > &, struct ca_client_context &, const char *pName, caCh *pConnCallBackIn, void *pPrivateIn, capri priority)
void	destructor (CallbackGuard &cbGuard, epicsGuard< epicsMutex > &mutexGuard)
unsigned	getName (epicsGuard< epicsMutex > &, char *pBuf, unsigned bufLen) const throw ()
void	show (epicsGuard< epicsMutex > &, unsigned level) const
void	initiateConnect (epicsGuard< epicsMutex > &)
void	read (epicsGuard< epicsMutex > &, unsigned type, arrayElementCount count, cacReadNotify &notify, cacChannel::ioid *pId=0)
void	write (epicsGuard< epicsMutex > &, unsigned type, arrayElementCount count, const void *pValue, cacWriteNotify &, cacChannel::ioid *pId=0)
void	ioCancel (CallbackGuard &callbackGuard, epicsGuard< epicsMutex > &mutualExclusionGuard, const cacChannel::ioid &)
void	ioShow (epicsGuard< epicsMutex > &guard, const cacChannel::ioid &, unsigned level) const
ca_client_context &	getClientCtx ()
void	eliminateExcessiveSendBacklog (epicsGuard< epicsMutex > &)
void *	operator new (size_t size, tsFreeList< struct oldChannelNotify, 1024, epicsMutexNOOP > &)

Friends
unsigned epicsStdCall	ca_get_host_name (chid pChan, char *pBuf, unsigned bufLength)
const char *epicsStdCall	ca_host_name (chid pChan)
const char *epicsStdCall	ca_name (chid pChan)
void epicsStdCall	ca_set_puser (chid pChan, void *puser)
void *epicsStdCall	ca_puser (chid pChan)
int epicsStdCall	ca_change_connection_event (chid pChan, caCh *pfunc)
int epicsStdCall	ca_replace_access_rights_event (chid pChan, caArh *pfunc)
int epicsStdCall	ca_array_get (chtype type, arrayElementCount count, chid pChan, void *pValue)
int epicsStdCall	ca_array_get_callback (chtype type, arrayElementCount count, chid pChan, caEventCallBackFunc *pfunc, void *arg)
int epicsStdCall	ca_array_put (chtype type, arrayElementCount count, chid pChan, const void *pValue)
int epicsStdCall	ca_array_put_callback (chtype type, arrayElementCount count, chid pChan, const void *pValue, caEventCallBackFunc *pfunc, void *usrarg)
double epicsStdCall	ca_beacon_period (chid pChan)
unsigned epicsStdCall	ca_search_attempts (chid pChan)
unsigned epicsStdCall	ca_write_access (chid pChan)
unsigned epicsStdCall	ca_read_access (chid pChan)
short epicsStdCall	ca_field_type (chid pChan)
arrayElementCount epicsStdCall	ca_element_count (chid pChan)
int epicsStdCall	ca_v42_ok (chid pChan)
int epicsStdCall	ca_create_subscription (chtype type, arrayElementCount count, chid pChan, long mask, caEventCallBackFunc *pCallBack, void *pCallBackArg, evid *monixptr)
enum channel_state epicsStdCall	ca_state (chid pChan)
double epicsStdCall	ca_receive_watchdog_delay (chid pChan)

Detailed Description

Definition at line 40 of file oldAccess.h.

Constructor & Destructor Documentation

oldChannelNotify::oldChannelNotify	(	epicsGuard< epicsMutex > &	guard,
		struct ca_client_context &	cacIn,
		const char *	pName,
		caCh *	pConnCallBackIn,
		void *	pPrivateIn,
		capri	priority
	)

Definition at line 44 of file oldChannelNotify.cpp.

                                            :
    cacCtx ( cacIn ),
    io ( cacIn.createChannel ( guard, pName, *this, priority ) ),
    pConnCallBack ( pConnCallBackIn ),
    pPrivate ( pPrivateIn ), pAccessRightsFunc ( cacNoopAccesRightsHandler ),
    ioSeqNo ( 0 ), currentlyConnected ( false ), prevConnected ( false )
{
    guard.assertIdenticalMutex ( cacIn.mutexRef () );
    this->ioSeqNo = cacIn.sequenceNumberOfOutstandingIO ( guard );
    if ( pConnCallBackIn == 0 ) {
        cacIn.incrementOutstandingIO ( guard, this->ioSeqNo );
    }
}

Member Function Documentation

void oldChannelNotify::destructor	(	CallbackGuard &	cbGuard,
		epicsGuard< epicsMutex > &	mutexGuard
	)

Definition at line 65 of file oldChannelNotify.cpp.

{
    mutexGuard.assertIdenticalMutex ( this->cacCtx.mutexRef () );
    this->io.destroy ( cbGuard, mutexGuard );
    // no need to worry about a connect preempting here because
    // the io (the nciu) has been destroyed above
    if ( this->pConnCallBack == 0 && ! this->currentlyConnected ) {
        this->cacCtx.decrementOutstandingIO ( mutexGuard, this->ioSeqNo );
    }
    this->~oldChannelNotify ();
}

void oldChannelNotify::eliminateExcessiveSendBacklog ( epicsGuard< epicsMutex > &  guard )

inline

Definition at line 468 of file oldAccess.h.

{
    this->cacCtx.eliminateExcessiveSendBacklog ( guard, this->io );
}

ca_client_context & oldChannelNotify::getClientCtx ( )

inline

Definition at line 428 of file oldAccess.h.

{
    return this->cacCtx;
}

unsigned oldChannelNotify::getName ( epicsGuard< epicsMutex > &  guard, char *  pBuf, unsigned  bufLen  ) const throw ( )

inline

Definition at line 433 of file oldAccess.h.

{
    return this->io.getName ( guard, pBuf, bufLen );
}

void oldChannelNotify::initiateConnect ( epicsGuard< epicsMutex > &  guard )

inline

Definition at line 447 of file oldAccess.h.

{
    this->io.initiateConnect ( guard );
}

void oldChannelNotify::ioCancel ( CallbackGuard &  callbackGuard, epicsGuard< epicsMutex > &  mutualExclusionGuard, const cacChannel::ioid &  id  )

inline

Definition at line 453 of file oldAccess.h.

{
    this->io.ioCancel ( callbackGuard, mutualExclusionGuard, id );
}

void oldChannelNotify::ioShow ( epicsGuard< epicsMutex > &  guard, const cacChannel::ioid &  id, unsigned  level  ) const

inline

Definition at line 461 of file oldAccess.h.

{
    this->io.ioShow ( guard, id, level );
}

void * oldChannelNotify::operator new ( size_t  size, tsFreeList< struct oldChannelNotify, 1024, epicsMutexNOOP > &  freeList  )

inline

Definition at line 474 of file oldAccess.h.

{
    return freeList.allocate ( size );
}

void oldChannelNotify::read	(	epicsGuard< epicsMutex > &	guard,
		unsigned	type,
		arrayElementCount	count,
		cacReadNotify &	notify,
		cacChannel::ioid *	pId = 0
	)

Definition at line 401 of file oldChannelNotify.cpp.

{
    this->io.read ( guard, type, count, notify, pId );
}

void oldChannelNotify::show ( epicsGuard< epicsMutex > &  guard, unsigned  level  ) const

inline

Definition at line 440 of file oldAccess.h.

{
    this->io.show ( guard, level );
}

void oldChannelNotify::write	(	epicsGuard< epicsMutex > &	guard,
		unsigned	type,
		arrayElementCount	count,
		const void *	pValue,
		cacWriteNotify &	notify,
		cacChannel::ioid *	pId = 0
	)

Definition at line 611 of file oldChannelNotify.cpp.

{
    this->io.write ( guard, type, count, pValue, notify, pId );
}

Friends And Related Function Documentation

int epicsStdCall ca_array_get ( chtype  type, arrayElementCount  count, chid  pChan, void *  pValue  )

friend

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;
}

int epicsStdCall ca_array_get_callback ( chtype  type, arrayElementCount  count, chid  pChan, caEventCallBackFunc *  pfunc, void *  arg  )

friend

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;
}

int epicsStdCall ca_array_put ( chtype  type, arrayElementCount  count, chid  pChan, const void *  pValue  )

friend

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;
}

int epicsStdCall ca_array_put_callback ( chtype  type, arrayElementCount  count, chid  pChan, const void *  pValue, caEventCallBackFunc *  pfunc, void *  usrarg  )

friend

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;
}

double epicsStdCall ca_beacon_period ( chid  pChan )

friend

Definition at line 686 of file oldChannelNotify.cpp.

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

int epicsStdCall ca_change_connection_event ( chid  pChan, caCh *  pfunc  )

friend

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;
}

int epicsStdCall ca_create_subscription ( chtype  type, arrayElementCount  count, chid  pChan, long  mask, caEventCallBackFunc *  pCallBack, void *  pCallBackArg, evid *  monixptr  )

friend

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;
    }
}

arrayElementCount epicsStdCall ca_element_count ( chid  pChan )

friend

Definition at line 630 of file oldChannelNotify.cpp.

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

short epicsStdCall ca_field_type ( chid  pChan )

friend

Definition at line 621 of file oldChannelNotify.cpp.

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

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

friend

Definition at line 175 of file oldChannelNotify.cpp.

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

const char* epicsStdCall ca_host_name ( chid  pChan )

friend

Definition at line 188 of file oldChannelNotify.cpp.

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

const char* epicsStdCall ca_name ( chid  pChan )

friend

Definition at line 674 of file oldChannelNotify.cpp.

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

void* epicsStdCall ca_puser ( chid  pChan )

friend

Definition at line 208 of file oldChannelNotify.cpp.

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

unsigned epicsStdCall ca_read_access ( chid  pChan )

friend

Definition at line 656 of file oldChannelNotify.cpp.

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

double epicsStdCall ca_receive_watchdog_delay ( chid  pChan )

friend

Definition at line 692 of file oldChannelNotify.cpp.

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

int epicsStdCall ca_replace_access_rights_event ( chid  pChan, caArh *  pfunc  )

friend

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;
}

unsigned epicsStdCall ca_search_attempts ( chid  pChan )

friend

Definition at line 680 of file oldChannelNotify.cpp.

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

void epicsStdCall ca_set_puser ( chid  pChan, void *  puser  )

friend

Definition at line 198 of file oldChannelNotify.cpp.

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

enum channel_state epicsStdCall ca_state ( chid  pChan )

friend

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;
    }
}

int epicsStdCall ca_v42_ok ( chid  pChan )

friend

Definition at line 701 of file oldChannelNotify.cpp.

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

unsigned epicsStdCall ca_write_access ( chid  pChan )

friend

Definition at line 665 of file oldChannelNotify.cpp.

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

---

The documentation for this struct was generated from the following files:

• modules/ca/src/client/oldAccess.h
• modules/ca/src/client/oldChannelNotify.cpp