This file is indexed.

/usr/include/sipxtapi/os/OsQueuedEvent.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
//
// 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 _OsQueuedEvent_h_
#define _OsQueuedEvent_h_

// SYSTEM INCLUDES

// APPLICATION INCLUDES
#include "os/OsDefs.h"
#include "os/OsBSem.h"
#include "os/OsMsgQ.h"
#include "os/OsNotification.h"
#include "os/OsTime.h"

// DEFINES
// MACROS
// EXTERNAL FUNCTIONS
// EXTERNAL VARIABLES
// CONSTANTS
// STRUCTS
// TYPEDEFS
// FORWARD DECLARATIONS

/**
*  @brief Queued events are used to send event notifications using a message queue.
*
*  When the corresponding event occurs, the Notifier sends a message the
*  designated message queue. The Listener must wait on the queue to receive
*  the event messages.
*
*     <h3>Background</h3>
*  First, a little bit of terminology.  The task that wishes to be notified
*  when an event occurs is the "Listener" task. The task that signals when
*  a given event occurs is the "Notifier" task.  A Notifier informs the
*  Listener that a given event has occurred by sending an "Event
*  Notification".
*
*     <h3>Expected Usage</h3>
*  The Listener passes an OsQueuedEvent object to the Notifier which
*  includes a message queue identifier for that message queue that will be
*  used for event notifications.  When the corresponding event occurs,
*  the Notifier sends a message the designated message queue.  The
*  Listener waits on the queue to receive the event notification.
*  This mechanism allows a task to receive notifications for multiple
*  events. The same message queue that is used to receive event
*  notifications may also be used to receive other types of messages.
*/
class OsQueuedEvent : public OsNotification
{
/* //////////////////////////// PUBLIC //////////////////////////////////// */
public:

/* ============================ CREATORS ================================== */

     /// Constructor
   OsQueuedEvent(OsMsgQ& rMsgQ, const intptr_t userData);

     /// Destructor
   virtual ~OsQueuedEvent();

/* ============================ MANIPULATORS ============================== */

     /// Set the event data and send an event message to the designated queue.
   virtual OsStatus signal(const intptr_t eventData);
     /**<
     *  @return The result of the message send operation.
     */

     /// Set the user data value for this object.
   virtual OsStatus setUserData(intptr_t userData);
     /**<
     *  @returns Always OS_SUCCESS.
     */

/* ============================ ACCESSORS ================================= */

     /// Return the user data specified when this object was constructed.
   virtual OsStatus getUserData(intptr_t& rUserData) const;
     /**<
     *  @returns Always OS_SUCCESS.
     */

/* ============================ INQUIRY =================================== */

/* //////////////////////////// PROTECTED ///////////////////////////////// */
protected:

/* //////////////////////////// PRIVATE /////////////////////////////////// */
private:

   intptr_t  mUserData;    ///< Data specified on behalf of the user and
                           ///<  not otherwise used by this class -- the user
                           ///<  data is specified as an argument to the class
                           ///<  constructor.
   OsMsgQ*   mpMsgQ;       ///< Message queue where event notifications will
                           ///<  be sent.

     /// Send an event message to the designated message queue.
   OsStatus doSendEventMsg(const int msgType, const intptr_t eventData) const;
     /**
     *  @return The result of the message send operation.
     */

     /// Copy constructor (not implemented for this class).
   OsQueuedEvent(const OsQueuedEvent& rOsQueuedEvent);

     /// Assignment operator (not implemented for this class).
   OsQueuedEvent& operator=(const OsQueuedEvent& rhs);

};

/* ============================ INLINE METHODS ============================ */

#endif  // _OsQueuedEvent_h_