/usr/include/sipxtapi/tapi/SipXHandleMap.h is in libsipxtapi-dev 3.3.0~test17-2.1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 | //
// Copyright (C) 2004-2006 SIPfoundry Inc.
// Licensed by SIPfoundry under the LGPL license.
//
// Copyright (C) 2004-2006 Pingtel Corp. All rights reserved.
// Licensed to SIPfoundry under a Contributor Agreement.
//
// $$
///////////////////////////////////////////////////////////////////////////////
#ifndef _SipXHandleMap_h_
#define _SipXHandleMap_h_
// SYSTEM INCLUDES
// APPLICATION INCLUDES
#include "os/OsMutex.h"
#include "utl/UtlHashMap.h"
// DEFINES
// MACROS
// EXTERNAL FUNCTIONS
// EXTERNAL VARIABLES
// CONSTANTS
// STRUCTS
// TYPEDEFS
typedef unsigned int SIPXHANDLE ;
// FORWARD DECLARATIONS
/**
* SipXHandleMap provides a very simple container that associates a void*
* with a handle value. The handle value is a unique incrementing number.
* In theory, we could get collisions if the numbers wrap, however, this
* is not designed for that type of call volume (millions of call per
* hour?)
* <p>
* Generally, use the allocHandle, removeHandle, and findHandle methods.
* lock() and unlock() methods are also provided for external iterators.
*/
class SipXHandleMap : public UtlHashMap
{
/* //////////////////////////// PUBLIC //////////////////////////////////// */
public:
/* ============================ CREATORS ================================== */
/**
* Default constructor
*/
SipXHandleMap(int startingHandle = 1);
/**
* Destructor
*/
virtual ~SipXHandleMap();
/* ============================ MANIPULATORS ============================== */
/**
* Adds a reference count to the handle lock. In this way, removeHandle is
* guarded against removal while a handle is in use.
* releaseHandleRef decrements the reference count.
* addHandleRef should only be used in very specific
* cases, when the handle might become invalid before it is needed again.
*/
void addHandleRef(SIPXHANDLE handle);
/**
* Allocate a unique handle and associate the designed pData value
* with that handle.
*
* @param pData Data to be associated with the newly allocated handle
*/
SIPXHANDLE allocHandle(const void* pData) ;
/**
* Find the data associated with the designated handle and return it.
*/
const void* findHandle(SIPXHANDLE handle) ;
/**
* Remove the handle and data assoicated with it from the map.
*/
const void* removeHandle(SIPXHANDLE handle) ;
/**
* Lock/guard access to the allocHandle, findHandle, and removeHandle
* routines. This is called automatically for those routines, however,
* should be called explicitly if using an external iterator on the map.
*/
void lock() ;
/**
* Unlock access to the allocHandle, findHandle, and removeHandle
* routines. This is called automatically for those routines, however,
* should be called explicitly if using an external iterator on the map.
*/
void unlock() ;
/* ============================ ACCESSORS ================================= */
void dump() ;
void dumpCalls();
/* ============================ INQUIRY =================================== */
/* //////////////////////////// PROTECTED ///////////////////////////////// */
protected:
OsMutex mLock ; /**< Locked used for addEntry and removeEntry */
SIPXHANDLE mNextHandle ; /**< Next available handle index */
/* //////////////////////////// PRIVATE /////////////////////////////////// */
private:
UtlHashMap mLockCountHash;
/**
* Decrements reference count for handle locking.
* This should only be called from withing
* removeHandle.
* So, removeHandle will only actually remove the handle and
* return a pointer when there are no outstanding locks.
*/
void releaseHandleRef(SIPXHANDLE handle);
};
/* ============================ INLINE METHODS ============================ */
#endif // _SipXHandleMap_h_
|